#include "apr_lua.h"
-APR_IMPLEMENT_OPTIONAL_HOOK_RUN_ALL(apw, WOMBAT, int, wombat_open,
+APR_IMPLEMENT_OPTIONAL_HOOK_RUN_ALL(apl, AP_LUA, int, lua_open,
(lua_State *L, apr_pool_t *p),
(L, p),
OK, DECLINED)
-APR_IMPLEMENT_OPTIONAL_HOOK_RUN_ALL(apw, WOMBAT, int, wombat_request,
+APR_IMPLEMENT_OPTIONAL_HOOK_RUN_ALL(apl, AP_LUA, int, lua_request,
(lua_State *L, request_rec *r),
(L, r),
OK, DECLINED)
ap_log_perror(APLOG_MARK, APLOG_WARNING, 0, r->pool, "Lua error: %s", lua_response);
}
-static void wombat_open_callback(lua_State *L, apr_pool_t *p, void* ctx) {
+static void lua_open_callback(lua_State *L, apr_pool_t *p, void* ctx) {
apr_lua_init(L, p);
- apw_load_apache2_lmodule(L);
- apw_load_request_lmodule(L, p);
- apw_load_config_lmodule(L);
+ apl_load_apache2_lmodule(L);
+ apl_load_request_lmodule(L, p);
+ apl_load_config_lmodule(L);
}
-static int wombat_open_hook(lua_State *L, apr_pool_t *p) {
- wombat_open_callback(L, p, NULL);
+static int lua_open_hook(lua_State *L, apr_pool_t *p) {
+ lua_open_callback(L, p, NULL);
return OK;
}
/*
-static apr_status_t wombathood(ap_filter_t *f, apr_bucket_brigade *bb) {
+static apr_status_t luahood(ap_filter_t *f, apr_bucket_brigade *bb) {
apr_bucket* b;
apr_status_t rs;
for ( b = APR_BRIGADE_FIRST(bb);
const char *buffer;
size_t bytes;
if (( rs = apr_bucket_read(b, &buffer, &bytes, APR_BLOCK_READ))) {
- ap_log_rerror(APLOG_MARK, APLOG_WARNING, rs, f->r, "read failure in wombathood");
+ ap_log_rerror(APLOG_MARK, APLOG_WARNING, rs, f->r, "read failure in luahood");
return rs;
}
char *mine = apr_pstrmemdup(f->r->pool, buffer, bytes);
/**
* "main"
*/
-static int wombat_handler(request_rec *r) {
+static int lua_handler(request_rec *r) {
if (strcmp(r->handler, "lua-script")) {
return DECLINED;
}
- ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "handling [%s] in mod_wombat", r->filename);
- apw_dir_cfg *dcfg = ap_get_module_config(r->per_dir_config, &lua_module);
+ ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "handling [%s] in mod_lua", r->filename);
+ apl_dir_cfg *dcfg = ap_get_module_config(r->per_dir_config, &lua_module);
if (!r->header_only) {
- apw_request_cfg* rcfg = ap_get_module_config(r->request_config, &lua_module);
+ apl_request_cfg* rcfg = ap_get_module_config(r->request_config, &lua_module);
mapped_request_details *d = rcfg->mapped_request_details;
- apw_vm_spec *spec = NULL;
+ apl_vm_spec *spec = NULL;
if (!d) {
d = apr_palloc(r->pool, sizeof(mapped_request_details));
- spec = apr_pcalloc(r->pool, sizeof(apw_vm_spec));
+ spec = apr_pcalloc(r->pool, sizeof(apl_vm_spec));
spec->scope = dcfg->vm_scope;
spec->pool = r->pool;
spec->file = r->filename;
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "request details scope:%u, cache:%u",
d->spec->scope,
d->spec->code_cache_style);
- const apw_dir_cfg* cfg = ap_get_module_config(r->per_dir_config, &lua_module);
- lua_State *L = apw_get_lua_state(r->pool,
+ const apl_dir_cfg* cfg = ap_get_module_config(r->per_dir_config, &lua_module);
+ lua_State *L = apl_get_lua_state(r->pool,
d->spec->file,
cfg->package_paths,
cfg->package_cpaths,
- &wombat_open_callback, NULL);
+ &lua_open_callback, NULL);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "got a vm!");
if (!L) {
ap_rputs("Unable to compile VM, see logs", r);
}
lua_getglobal(L, d->function_name);
- apw_run_wombat_request(L, r);
+ apl_run_lua_request(L, r);
if (lua_pcall(L, 1, 0, 0)) {
report_lua_error(L, r);
}
/**
* Like mod_alias except for lua handler fun :-)
*/
-static int apw_alias_munger(request_rec *r) {
- const apw_dir_cfg *cfg = ap_get_module_config(r->per_dir_config, &lua_module);
+static int apl_alias_munger(request_rec *r) {
+ const apl_dir_cfg *cfg = ap_get_module_config(r->per_dir_config, &lua_module);
int i;
ap_regmatch_t matches[AP_MAX_REG_MATCH];
for (i = 0; i < cfg->mapped_handlers->nelts; i++) {
- const apw_mapped_handler_spec *cnd = ((const apw_mapped_handler_spec**)cfg->mapped_handlers->elts)[i];
+ const apl_mapped_handler_spec *cnd = ((const apl_mapped_handler_spec**)cfg->mapped_handlers->elts)[i];
if (OK == ap_regexec(cnd->uri_pattern, r->uri, AP_MAX_REG_MATCH, matches, 0)) {
r->handler = "lua-script";
- apw_vm_spec *spec = apr_pcalloc(r->pool, sizeof(apw_vm_spec));
+ apl_vm_spec *spec = apr_pcalloc(r->pool, sizeof(apl_vm_spec));
spec->file = ap_pregsub(r->pool, cnd->file_name, r->uri, AP_MAX_REG_MATCH, matches);
spec->scope = cnd->scope;
spec->code_cache_style = cnd->code_cache_style;
spec->bytecode = cnd->bytecode;
spec->bytecode_len = cnd->bytecode_len;
- if (spec->scope == APW_SCOPE_ONCE) {
+ if (spec->scope == APL_SCOPE_ONCE) {
spec->pool = r->pool;
}
/* now do replacement on method name where? */
r->filename = apr_pstrdup(r->pool, spec->file);
- apw_request_cfg *rcfg = ap_get_module_config(r->request_config, &lua_module);
+ apl_request_cfg *rcfg = ap_get_module_config(r->request_config, &lua_module);
rcfg->mapped_request_details = d;
return OK;
}
/** harnesses for magic hooks **/
-static int wombat_request_rec_hook_harness(request_rec *r, const char *name) {
+static int lua_request_rec_hook_harness(request_rec *r, const char *name) {
char *fixed_filename;
- const apw_dir_cfg* cfg = (apw_dir_cfg*) ap_get_module_config(r->per_dir_config,
+ const apl_dir_cfg* cfg = (apl_dir_cfg*) ap_get_module_config(r->per_dir_config,
&lua_module);
apr_array_header_t *hook_specs = apr_hash_get(cfg->hooks, name, APR_HASH_KEY_STRING);
if (hook_specs) {
int i;
for (i=0; i < hook_specs->nelts; i++) {
- apw_mapped_handler_spec *hook_spec = ((apw_mapped_handler_spec**)hook_specs->elts)[i];
+ apl_mapped_handler_spec *hook_spec = ((apl_mapped_handler_spec**)hook_specs->elts)[i];
if (hook_spec == NULL) continue;
- apw_vm_spec *spec = apr_pcalloc(r->pool, sizeof(apw_vm_spec));
+ apl_vm_spec *spec = apr_pcalloc(r->pool, sizeof(apl_vm_spec));
spec->file = hook_spec->file_name;
spec->code_cache_style = hook_spec->code_cache_style;
spec->pool = r->pool;
/*
- const apw_dir_cfg* cfg = ap_get_module_config(r->per_dir_config, &lua_module);
- lua_State *L = apw_get_lua_state(r->pool,
+ const apl_dir_cfg* cfg = ap_get_module_config(r->per_dir_config, &lua_module);
+ lua_State *L = apl_get_lua_state(r->pool,
d->spec->file,
cfg->package_paths,
cfg->package_cpaths,
- &wombat_open_callback, NULL);
+ &lua_open_callback, NULL);
*/
- apw_server_cfg *server_cfg = ap_get_module_config(r->server->module_config, &lua_module);
+ apl_server_cfg *server_cfg = ap_get_module_config(r->server->module_config, &lua_module);
apr_filepath_merge(&fixed_filename, server_cfg->root_path, spec->file, APR_FILEPATH_NOTRELATIVE, r->pool);
- lua_State *L = apw_get_lua_state(r->pool,
+ lua_State *L = apl_get_lua_state(r->pool,
fixed_filename,
cfg->package_paths,
cfg->package_cpaths,
- &wombat_open_callback, NULL);
+ &lua_open_callback, NULL);
if (!L) {
- ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, "wombat: Failed to obtain lua interpreter for %s %s",
+ ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, "lua: Failed to obtain lua interpreter for %s %s",
hook_spec->function_name,
hook_spec->file_name);
return 500;
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, "wombat: Unable to find function %s in %s",
+ ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, "lua: Unable to find function %s in %s",
hook_spec->function_name,
hook_spec->file_name);
return 500;
}
- apw_run_wombat_request(L, r);
+ apl_run_lua_request(L, r);
}
else {
- apw_run_wombat_request(L, r);
+ apl_run_lua_request(L, r);
int t = lua_gettop(L);
lua_setglobal(L, "r");
typedef struct hack_section_baton {
const char *name;
- apw_mapped_handler_spec *spec;
+ apl_mapped_handler_spec *spec;
} hack_section_baton;
/* You can be unhappy now.
*/
static const char *hack_section_handler(cmd_parms *cmd, void *_cfg, const char *arg)
{
- apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+ apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
ap_directive_t *directive = cmd->directive;
hack_section_baton* baton = directive->data;
apr_array_header_t *hook_specs = apr_hash_get(cfg->hooks, baton->name, APR_HASH_KEY_STRING);
if (!hook_specs) {
- hook_specs = apr_array_make(cmd->pool, 2, sizeof(apw_mapped_handler_spec*));
+ hook_specs = apr_array_make(cmd->pool, 2, sizeof(apl_mapped_handler_spec*));
apr_hash_set(cfg->hooks, apr_pstrdup(cmd->pool, baton->name), APR_HASH_KEY_STRING, hook_specs);
}
baton->spec->scope = cfg->vm_scope;
- *(apw_mapped_handler_spec**)apr_array_push(hook_specs) = baton->spec;
+ *(apl_mapped_handler_spec**)apr_array_push(hook_specs) = baton->spec;
return NULL;
}
}
}
- apw_mapped_handler_spec *spec = apr_pcalloc(cmd->pool, sizeof(apw_mapped_handler_spec));
+ apl_mapped_handler_spec *spec = apr_pcalloc(cmd->pool, sizeof(apl_mapped_handler_spec));
{
cr_ctx ctx;
else {
function = NULL;
}
- spec->code_cache_style = APW_CODE_CACHE_FOREVER;
+ spec->code_cache_style = APL_CODE_CACHE_FOREVER;
ctx.cmd = cmd;
tmp = apr_pstrdup(cmd->pool, cmd->err_directive->directive+1);
void *_cfg,
const char *file,
const char *function) {
- apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+ apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
apr_array_header_t *hook_specs = apr_hash_get(cfg->hooks, name, APR_HASH_KEY_STRING);
if (!hook_specs) {
- hook_specs = apr_array_make(cmd->pool, 2, sizeof(apw_mapped_handler_spec*));
+ hook_specs = apr_array_make(cmd->pool, 2, sizeof(apl_mapped_handler_spec*));
apr_hash_set(cfg->hooks, apr_pstrdup(cmd->pool, name), APR_HASH_KEY_STRING, hook_specs);
}
- apw_mapped_handler_spec *spec = apr_pcalloc(cmd->pool, sizeof(apw_mapped_handler_spec));
+ apl_mapped_handler_spec *spec = apr_pcalloc(cmd->pool, sizeof(apl_mapped_handler_spec));
spec->file_name = apr_pstrdup(cmd->pool, file);
spec->function_name = apr_pstrdup(cmd->pool, function);
spec->scope = cfg->vm_scope;
- spec->code_cache_style = APW_CODE_CACHE_STAT;
+ spec->code_cache_style = APL_CODE_CACHE_STAT;
/*
int code_cache_style;
char *function_name;
char *file_name;
int scope;
*/
- *(apw_mapped_handler_spec**)apr_array_push(hook_specs) = spec;
+ *(apl_mapped_handler_spec**)apr_array_push(hook_specs) = spec;
return NULL;
}
-int wombat_check_user_id_harness(request_rec *r) {
- return wombat_request_rec_hook_harness(r, "check_user_id");
+int lua_check_user_id_harness(request_rec *r) {
+ return lua_request_rec_hook_harness(r, "check_user_id");
}
-int wombat_translate_name_harness(request_rec *r) {
- return wombat_request_rec_hook_harness(r, "translate_name");
+int lua_translate_name_harness(request_rec *r) {
+ return lua_request_rec_hook_harness(r, "translate_name");
}
-int wombat_fixup_harness(request_rec *r) {
- return wombat_request_rec_hook_harness(r, "fixups");
+int lua_fixup_harness(request_rec *r) {
+ return lua_request_rec_hook_harness(r, "fixups");
}
-int wombat_map_to_storage_harness(request_rec *r) {
- return wombat_request_rec_hook_harness(r, "map_to_storage");
+int lua_map_to_storage_harness(request_rec *r) {
+ return lua_request_rec_hook_harness(r, "map_to_storage");
}
-int wombat_type_checker_harness(request_rec *r) {
- return wombat_request_rec_hook_harness(r, "type_checker");
+int lua_type_checker_harness(request_rec *r) {
+ return lua_request_rec_hook_harness(r, "type_checker");
}
-int wombat_access_checker_harness(request_rec *r) {
- return wombat_request_rec_hook_harness(r, "access_checker");
+int lua_access_checker_harness(request_rec *r) {
+ return lua_request_rec_hook_harness(r, "access_checker");
}
-int wombat_auth_checker_harness(request_rec *r) {
- return wombat_request_rec_hook_harness(r, "auth_checker");
+int lua_auth_checker_harness(request_rec *r) {
+ return lua_request_rec_hook_harness(r, "auth_checker");
}
-void wombat_insert_filter_harness(request_rec *r) {
+void lua_insert_filter_harness(request_rec *r) {
/* ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, "LuaHookInsertFilter not yet implemented"); */
}
-int wombat_quick_harness(request_rec *r, int lookup) {
+int lua_quick_harness(request_rec *r, int lookup) {
if(lookup) {
return DECLINED;
}
- return wombat_request_rec_hook_harness(r, "quick");
+ return lua_request_rec_hook_harness(r, "quick");
}
static const char* register_translate_name_hook(cmd_parms *cmd, void *_cfg, const char *file, const char *function) {
static const char* register_package_helper(cmd_parms *cmd, const char *arg, apr_array_header_t *dir_array) {
apr_status_t rv;
- apw_server_cfg *server_cfg = ap_get_module_config(cmd->server->module_config, &lua_module);
+ apl_server_cfg *server_cfg = ap_get_module_config(cmd->server->module_config, &lua_module);
char *fixed_filename;
rv = apr_filepath_merge(&fixed_filename, server_cfg->root_path, arg, APR_FILEPATH_NOTRELATIVE, cmd->pool);
if (rv != APR_SUCCESS) {
* LuaPackagePath /lua/package/path/mapped/thing/like/this/?.lua
*/
const char* register_package_dir(cmd_parms *cmd, void *_cfg, const char *arg) {
- apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+ apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
return register_package_helper(cmd, arg, cfg->package_paths);
}
* LuaPackageCPath /lua/package/path/mapped/thing/like/this/?.so
*/
const char* register_package_cdir(cmd_parms *cmd, void *_cfg, const char *arg) {
- apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+ apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
return register_package_helper(cmd, arg, cfg->package_cpaths);
}
* LuaCodeCache
*/
const char* register_code_cache(cmd_parms *cmd, void *_cfg, const char *arg) {
- apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+ apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
if (apr_strnatcmp("stat", arg) == 0) {
- cfg->code_cache_style = APW_CODE_CACHE_STAT;
+ cfg->code_cache_style = APL_CODE_CACHE_STAT;
}
else if (apr_strnatcmp("forever", arg) == 0) {
- cfg->code_cache_style = APW_CODE_CACHE_FOREVER;
+ cfg->code_cache_style = APL_CODE_CACHE_FOREVER;
}
else if (apr_strnatcmp("never", arg) == 0) {
- cfg->code_cache_style = APW_CODE_CACHE_NEVER;
+ cfg->code_cache_style = APL_CODE_CACHE_NEVER;
}
else {
return apr_psprintf(cmd->pool,
static const char* register_lua_scope(cmd_parms *cmd, void *_cfg, const char *scope,
const char *min,
const char *max) {
- apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+ apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
if (apr_strnatcmp("once", scope) == 0) {
- cfg->vm_scope = APW_SCOPE_ONCE;
+ cfg->vm_scope = APL_SCOPE_ONCE;
}
else if (apr_strnatcmp("request", scope) == 0) {
- cfg->vm_scope = APW_SCOPE_REQUEST;
+ cfg->vm_scope = APL_SCOPE_REQUEST;
}
else if (apr_strnatcmp("conn", scope) == 0) {
- cfg->vm_scope = APW_SCOPE_CONN;
+ cfg->vm_scope = APL_SCOPE_CONN;
}
else if (apr_strnatcmp("server", scope) == 0) {
- cfg->vm_scope = APW_SCOPE_SERVER;
+ cfg->vm_scope = APL_SCOPE_SERVER;
if (min) cfg->vm_server_pool_min = atoi(min);
if (max) cfg->vm_server_pool_max = atoi(max);
}
* AddLuaHandler /alias /path/to/lua/file.lua [handler_function_name]
*/
static const char* lua_map_handler(cmd_parms *cmd, void *_cfg, const char *path, const char *file, const char *function) {
- apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+ apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
const char *function_name;
function_name = function ? function : "handle";
apr_status_t rv;
- rv = apw_lua_map_handler(cfg, file, function_name, path, "once");
+ rv = apl_lua_map_handler(cfg, file, function_name, path, "once");
if (rv != APR_SUCCESS) {
return apr_psprintf(cmd->pool, "Unable to configure a lua handler for path '%s', handler %s#%s",
path, file, function_name);
}
static const char* register_lua_root(cmd_parms *cmd, void *_cfg, const char *root) {
- /* apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg; */
- apw_server_cfg* cfg = ap_get_module_config(cmd->server->module_config, &lua_module);
+ /* apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg; */
+ apl_server_cfg* cfg = ap_get_module_config(cmd->server->module_config, &lua_module);
cfg->root_path = root;
return NULL;
/*******************************/
-command_rec wombat_commands[] = {
+command_rec lua_commands[] = {
AP_INIT_TAKE1("LuaRoot", register_lua_root, NULL, OR_ALL,
- "Specify the base path for resolving relative paths for mod_wombat directives"),
+ "Specify the base path for resolving relative paths for mod_lua directives"),
AP_INIT_TAKE1("LuaPackagePath", register_package_dir, NULL, OR_ALL,
static void* create_dir_config(apr_pool_t *p, char *dir) {
- apw_dir_cfg* cfg = apr_pcalloc(p, sizeof(apw_dir_cfg));
+ apl_dir_cfg* cfg = apr_pcalloc(p, sizeof(apl_dir_cfg));
cfg->package_paths = apr_array_make(p, 2, sizeof(char*));
cfg->package_cpaths = apr_array_make(p, 2, sizeof(char*));
- cfg->mapped_handlers = apr_array_make(p, 1, sizeof(apw_mapped_handler_spec*));
- cfg->code_cache_style = APW_CODE_CACHE_STAT;
+ cfg->mapped_handlers = apr_array_make(p, 1, sizeof(apl_mapped_handler_spec*));
+ cfg->code_cache_style = APL_CODE_CACHE_STAT;
cfg->pool = p;
cfg->hooks = apr_hash_make(p);
cfg->dir = apr_pstrdup(p, dir);
- cfg->vm_scope = APW_SCOPE_ONCE;
+ cfg->vm_scope = APL_SCOPE_ONCE;
return cfg;
}
static int create_request_config(request_rec *r) {
- apw_request_cfg *cfg = apr_palloc(r->pool, sizeof(apw_request_cfg));
+ apl_request_cfg *cfg = apr_palloc(r->pool, sizeof(apl_request_cfg));
cfg->mapped_request_details = NULL;
cfg->request_scoped_vms = apr_hash_make(r->pool);
ap_set_module_config(r->request_config, &lua_module, cfg);
static void* create_server_config(apr_pool_t *p, server_rec *s) {
- apw_server_cfg *cfg = apr_pcalloc(p, sizeof(apw_server_cfg));
- cfg->code_cache = apr_pcalloc(p, sizeof(apw_code_cache));
+ apl_server_cfg *cfg = apr_pcalloc(p, sizeof(apl_server_cfg));
+ cfg->code_cache = apr_pcalloc(p, sizeof(apl_code_cache));
apr_thread_rwlock_create(&cfg->code_cache->compiled_files_lock, p);
cfg->code_cache->compiled_files = apr_hash_make(p);
cfg->vm_reslists = apr_hash_make(p);
return cfg;
}
-static int wombat_request_hook(lua_State *L, request_rec *r) {
- apw_push_request(L, r);
+static int lua_request_hook(lua_State *L, request_rec *r) {
+ apl_push_request(L, r);
return OK;
}
-static void wombat_register_hooks(apr_pool_t *p) {
- /* ap_register_output_filter("wombathood", wombathood, NULL, AP_FTYPE_RESOURCE); */
- ap_hook_handler(wombat_handler, NULL, NULL, APR_HOOK_MIDDLE);
+static void lua_register_hooks(apr_pool_t *p) {
+ /* ap_register_output_filter("luahood", luahood, NULL, AP_FTYPE_RESOURCE); */
+ ap_hook_handler(lua_handler, NULL, NULL, APR_HOOK_MIDDLE);
ap_hook_create_request(create_request_config, NULL, NULL, APR_HOOK_MIDDLE);
/* http_request.h hooks */
- ap_hook_translate_name(wombat_translate_name_harness, NULL, NULL, APR_HOOK_MIDDLE);
- ap_hook_fixups(wombat_fixup_harness, NULL, NULL, APR_HOOK_MIDDLE);
- ap_hook_map_to_storage(wombat_map_to_storage_harness, NULL, NULL, APR_HOOK_MIDDLE);
- ap_hook_check_user_id(wombat_check_user_id_harness, NULL, NULL, APR_HOOK_MIDDLE);
- ap_hook_type_checker(wombat_type_checker_harness, NULL, NULL, APR_HOOK_MIDDLE);
- ap_hook_access_checker(wombat_access_checker_harness, NULL, NULL, APR_HOOK_MIDDLE);
- ap_hook_auth_checker(wombat_auth_checker_harness, NULL, NULL, APR_HOOK_MIDDLE);
- ap_hook_insert_filter(wombat_insert_filter_harness, NULL, NULL, APR_HOOK_MIDDLE);
- ap_hook_quick_handler(wombat_quick_harness, NULL, NULL, APR_HOOK_FIRST);
-
- /* ap_hook_translate_name(wombat_alias_munger, NULL, NULL, APR_HOOK_MIDDLE); */
- ap_hook_translate_name(apw_alias_munger, NULL, NULL, APR_HOOK_MIDDLE);
-
- APR_OPTIONAL_HOOK(apw, wombat_open, wombat_open_hook, NULL, NULL,
+ ap_hook_translate_name(lua_translate_name_harness, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_fixups(lua_fixup_harness, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_map_to_storage(lua_map_to_storage_harness, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_check_user_id(lua_check_user_id_harness, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_type_checker(lua_type_checker_harness, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_access_checker(lua_access_checker_harness, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_auth_checker(lua_auth_checker_harness, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_insert_filter(lua_insert_filter_harness, NULL, NULL, APR_HOOK_MIDDLE);
+ ap_hook_quick_handler(lua_quick_harness, NULL, NULL, APR_HOOK_FIRST);
+
+ /* ap_hook_translate_name(lua_alias_munger, NULL, NULL, APR_HOOK_MIDDLE); */
+ ap_hook_translate_name(apl_alias_munger, NULL, NULL, APR_HOOK_MIDDLE);
+
+ APR_OPTIONAL_HOOK(apl, lua_open, lua_open_hook, NULL, NULL,
APR_HOOK_REALLY_FIRST);
- APR_OPTIONAL_HOOK(apw, wombat_request, wombat_request_hook, NULL, NULL,
+ APR_OPTIONAL_HOOK(apl, lua_request, lua_request_hook, NULL, NULL,
APR_HOOK_REALLY_FIRST);
}
NULL, /* merge per-dir config structures */
create_server_config, /* create per-server config structures */
NULL, /* merge per-server config structures */
- wombat_commands, /* table of config file commands */
- wombat_register_hooks /* register hooks */
+ lua_commands, /* table of config file commands */
+ lua_register_hooks /* register hooks */
};
* userdata thingamajig and return it if it is. if it is not
* lua will enter its error handling routine.
*/
-static request_rec* apw_check_request_rec(lua_State* L, int index) {
+static request_rec* apl_check_request_rec(lua_State* L, int index) {
luaL_checkudata(L, index, "Apache2.Request");
request_rec* r = (request_rec*)lua_unboxpointer(L, index);
return r;
/* r:parseargs() returning a lua table */
static int req_parseargs(lua_State* L) {
- request_rec* r = apw_check_request_rec(L, 1);
+ request_rec* r = apl_check_request_rec(L, 1);
lua_newtable(L);
lua_newtable(L); /* [table, table] */
apr_table_t* form_table;
/* wrap ap_rputs as r:puts(String) */
static int req_puts(lua_State* L) {
- request_rec* r = apw_check_request_rec(L, 1);
+ request_rec* r = apl_check_request_rec(L, 1);
int argc = lua_gettop(L);
int i;
/* wrap ap_rwrite as r:write(String) */
static int req_write(lua_State* L) {
- request_rec* r = apw_check_request_rec(L, 1);
+ request_rec* r = apl_check_request_rec(L, 1);
size_t n;
const char* buf = luaL_checklstring(L, 2, &n);
/* r:parsebody() */
static int req_parsebody(lua_State* L) {
- request_rec* r = apw_check_request_rec(L, 1);
+ request_rec* r = apl_check_request_rec(L, 1);
lua_newtable(L);
lua_newtable(L);
apr_table_t* form_table;
/* r:addoutputfilter(name|function) */
static int req_add_output_filter(lua_State *L) {
- request_rec* r = apw_check_request_rec(L, 1);
+ request_rec* r = apl_check_request_rec(L, 1);
const char *name = luaL_checkstring(L, 2);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "adding output filter %s", name);
ap_add_output_filter(name, L, r, r->connection);
}
static int req_document_root(lua_State* L) {
- request_rec* r = apw_check_request_rec(L, 1);
+ request_rec* r = apl_check_request_rec(L, 1);
char* doc_root = apr_pstrdup(r->pool, ap_document_root(r));
lua_pushstring(L, doc_root);
return 1;
/* END dispatch mathods for request_rec fields */
static int req_dispatch(lua_State* L) {
- request_rec* r = apw_check_request_rec(L, 1);
+ request_rec* r = apl_check_request_rec(L, 1);
const char *name = luaL_checkstring(L, 2);
lua_pop(L, 2);
req_fun_t* rft = apr_hash_get(dispatch, name, APR_HASH_KEY_STRING);
if (rft) {
switch(rft->type) {
- case APW_REQ_FUNTYPE_TABLE: {
+ case APL_REQ_FUNTYPE_TABLE: {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"request_rec->dispatching %s -> apr table (NOT IMPLEMENTED YET)", name);
return 0;
}
- case APW_REQ_FUNTYPE_LUACFUN: {
+ case APL_REQ_FUNTYPE_LUACFUN: {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"request_rec->dispatching %s -> lua_CFunction", name);
lua_CFunction func = rft->fun;
lua_pushcfunction(L, func);
return 1;
}
- case APW_REQ_FUNTYPE_STRING: {
+ case APL_REQ_FUNTYPE_STRING: {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"request_rec->dispatching %s -> string", name);
req_field_string_f func = rft->fun;
lua_pushstring(L, rs);
return 1;
}
- case APW_REQ_FUNTYPE_INT: {
+ case APL_REQ_FUNTYPE_INT: {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"request_rec->dispatching %s -> int", name);
req_field_int_f func = rft->fun;
lua_pushnumber(L, rs);
return 1;
}
- case APW_REQ_FUNTYPE_BOOLEAN: {
+ case APL_REQ_FUNTYPE_BOOLEAN: {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
"request_rec->dispatching %s -> boolean", name);
req_field_int_f func = rft->fun;
/* helper function for the logging functions below */
static int req_log_at(lua_State* L, int level) {
- request_rec* r = apw_check_request_rec(L, 1);
+ request_rec* r = apl_check_request_rec(L, 1);
lua_Debug dbg;
lua_getstack(L, 1, &dbg);
static int req_newindex(lua_State* L) {
/* request_rec* r = lua_touserdata(L, lua_upvalueindex(1)); */
/* const char* key = luaL_checkstring(L, -2); */
- request_rec* r = apw_check_request_rec(L, 1);
+ request_rec* r = apl_check_request_rec(L, 1);
rstack_dump(L, r, "req_newindex");
const char *key = luaL_checkstring(L, 2);
rstack_dump(L, r, "req_newindex");
return rft;
}
-void apw_load_request_lmodule(lua_State *L, apr_pool_t *p) {
+void apl_load_request_lmodule(lua_State *L, apr_pool_t *p) {
apr_hash_t* dispatch = apr_hash_make(p);
apr_hash_set(dispatch, "puts", APR_HASH_KEY_STRING,
- makefun(&req_puts, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_puts, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "write", APR_HASH_KEY_STRING,
- makefun(&req_write, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_write, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "document_root", APR_HASH_KEY_STRING,
- makefun(&req_document_root, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_document_root, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "parseargs", APR_HASH_KEY_STRING,
- makefun(&req_parseargs, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_parseargs, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "parsebody", APR_HASH_KEY_STRING,
- makefun(&req_parsebody, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_parsebody, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "debug", APR_HASH_KEY_STRING,
- makefun(&req_debug, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_debug, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "info", APR_HASH_KEY_STRING,
- makefun(&req_info, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_info, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "notice", APR_HASH_KEY_STRING,
- makefun(&req_notice, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_notice, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "warn", APR_HASH_KEY_STRING,
- makefun(req_warn, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(req_warn, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "err", APR_HASH_KEY_STRING,
- makefun(&req_err, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_err, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "crit", APR_HASH_KEY_STRING,
- makefun(&req_crit, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_crit, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "alert", APR_HASH_KEY_STRING,
- makefun(&req_alert, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_alert, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "emerg", APR_HASH_KEY_STRING,
- makefun(&req_emerg, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_emerg, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "add_output_filter", APR_HASH_KEY_STRING,
- makefun(&req_add_output_filter, APW_REQ_FUNTYPE_LUACFUN, p));
+ makefun(&req_add_output_filter, APL_REQ_FUNTYPE_LUACFUN, p));
apr_hash_set(dispatch, "assbackwards", APR_HASH_KEY_STRING,
- makefun(&req_assbackwards_field, APW_REQ_FUNTYPE_BOOLEAN, p));
+ makefun(&req_assbackwards_field, APL_REQ_FUNTYPE_BOOLEAN, p));
apr_hash_set(dispatch, "status", APR_HASH_KEY_STRING,
- makefun(&req_status_field, APW_REQ_FUNTYPE_INT, p));
+ makefun(&req_status_field, APL_REQ_FUNTYPE_INT, p));
apr_hash_set(dispatch, "protocol", APR_HASH_KEY_STRING,
- makefun(&req_protocol_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_protocol_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "range", APR_HASH_KEY_STRING,
- makefun(&req_range_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_range_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "content_type", APR_HASH_KEY_STRING,
- makefun(&req_content_type_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_content_type_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "content_encoding", APR_HASH_KEY_STRING,
- makefun(&req_content_encoding_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_content_encoding_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "ap_auth_type", APR_HASH_KEY_STRING,
- makefun(&req_ap_auth_type_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_ap_auth_type_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "unparsed_uri", APR_HASH_KEY_STRING,
- makefun(&req_unparsed_uri_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_unparsed_uri_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "user", APR_HASH_KEY_STRING,
- makefun(&req_user_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_user_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "filename", APR_HASH_KEY_STRING,
- makefun(&req_filename_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_filename_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "canonical_filename", APR_HASH_KEY_STRING,
- makefun(&req_canonical_filename_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_canonical_filename_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "path_info", APR_HASH_KEY_STRING,
- makefun(&req_path_info_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_path_info_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "args", APR_HASH_KEY_STRING,
- makefun(&req_args_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_args_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "hostname", APR_HASH_KEY_STRING,
- makefun(&req_hostname_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_hostname_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "uri", APR_HASH_KEY_STRING,
- makefun(&req_uri_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_uri_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "the_request", APR_HASH_KEY_STRING,
- makefun(&req_the_request_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_the_request_field, APL_REQ_FUNTYPE_STRING, p));
apr_hash_set(dispatch, "method", APR_HASH_KEY_STRING,
- makefun(&req_method_field, APW_REQ_FUNTYPE_STRING, p));
+ makefun(&req_method_field, APL_REQ_FUNTYPE_STRING, p));
lua_pushlightuserdata(L, dispatch);
lua_setfield(L, LUA_REGISTRYINDEX, "Apache2.Request.dispatch");
}
-void apw_push_connection(lua_State* L, conn_rec* c) {
+void apl_push_connection(lua_State* L, conn_rec* c) {
lua_boxpointer(L, c);
luaL_getmetatable(L, "Apache2.Connection");
lua_setmetatable(L, -2);
luaL_getmetatable(L, "Apache2.Connection");
- apw_push_apr_table(L, "notes", c->notes);
+ apl_push_apr_table(L, "notes", c->notes);
lua_pushstring(L, c->remote_ip);
lua_setfield(L, -2, "remote_ip");
}
-void apw_push_server(lua_State* L, server_rec* s) {
+void apl_push_server(lua_State* L, server_rec* s) {
lua_boxpointer(L, s);
luaL_getmetatable(L, "Apache2.Server");
lua_setmetatable(L, -2);
lua_pop(L, 1);
}
-void apw_push_request(lua_State* L, request_rec* r) {
+void apl_push_request(lua_State* L, request_rec* r) {
lua_boxpointer(L, r);
luaL_getmetatable(L, "Apache2.Request");
lua_setmetatable(L, -2);
projects / apache / commitdiff