diff options
Diffstat (limited to 'modules/lua')
39 files changed, 10002 insertions, 0 deletions
diff --git a/modules/lua/Makefile.in b/modules/lua/Makefile.in new file mode 100644 index 0000000..7c5c149 --- /dev/null +++ b/modules/lua/Makefile.in @@ -0,0 +1,3 @@ +# a modules Makefile has no explicit targets -- they will be defined by +# whatever modules are enabled. just grab special.mk to deal with this. +include $(top_srcdir)/build/special.mk diff --git a/modules/lua/NWGNUmakefile b/modules/lua/NWGNUmakefile new file mode 100644 index 0000000..24f2703 --- /dev/null +++ b/modules/lua/NWGNUmakefile @@ -0,0 +1,287 @@ +# +# Declare the sub-directories to be built here +# + +SUBDIRS = \ + $(EOLIST) + +# +# Get the 'head' of the build environment. This includes default targets and +# paths to tools +# + +include $(AP_WORK)/build/NWGNUhead.inc + +# +# build this level's files + +# +# Make sure all needed macro's are defined +# + +# +# These directories will be at the beginning of the include list, followed by +# INCDIRS +# +XINCDIRS += \ + $(APR)/include \ + $(APRUTIL)/include \ + $(SRC)/include \ + $(STDMOD)/database \ + $(STDMOD)/http \ + $(STDMOD)/ssl \ + $(NWOS) \ + $(LUASRC)/src \ + $(EOLIST) + +# +# These flags will come after CFLAGS +# +XCFLAGS += \ + -opt nointrinsics \ + $(EOLIST) + +# +# These defines will come after DEFINES +# +XDEFINES += \ + -DLUA_COMPAT_ALL \ + -DLUA_COMPAT_5_2 \ + -DLUA_COMPAT_5_1 \ + -DLUA_COMPAT_MODULE \ + $(EOLIST) + +# +# These flags will be added to the link.opt file +# +XLFLAGS += \ + -L$(OBJDIR) \ + $(EOLIST) + +# +# These values will be appended to the correct variables based on the value of +# RELEASE +# +ifeq "$(RELEASE)" "debug" +XINCDIRS += \ + $(EOLIST) + +XCFLAGS += \ + $(EOLIST) + +XDEFINES += \ + $(EOLIST) + +XLFLAGS += \ + $(EOLIST) +endif + +ifeq "$(RELEASE)" "noopt" +XINCDIRS += \ + $(EOLIST) + +XCFLAGS += \ + $(EOLIST) + +XDEFINES += \ + $(EOLIST) + +XLFLAGS += \ + $(EOLIST) +endif + +ifeq "$(RELEASE)" "release" +XINCDIRS += \ + $(EOLIST) + +XCFLAGS += \ + $(EOLIST) + +XDEFINES += \ + $(EOLIST) + +XLFLAGS += \ + $(EOLIST) +endif + +# +# These are used by the link target if an NLM is being generated +# This is used by the link 'name' directive to name the nlm. If left blank +# TARGET_nlm (see below) will be used. +# +NLM_NAME = mod_lua + +# +# This is used by the link '-desc ' directive. +# If left blank, NLM_NAME will be used. +# +NLM_DESCRIPTION = Apache $(VERSION_STR) LUA Module + +# +# This is used by the '-threadname' directive. If left blank, +# NLM_NAME Thread will be used. +# +NLM_THREAD_NAME = LUA Module + +# +# If this is specified, it will override VERSION value in +# $(AP_WORK)/build/NWGNUenvironment.inc +# +NLM_VERSION = + +# +# If this is specified, it will override the default of 64K +# +NLM_STACK_SIZE = 131072 + + +# +# If this is specified it will be used by the link '-entry' directive +# +NLM_ENTRY_SYM = + +# +# If this is specified it will be used by the link '-exit' directive +# +NLM_EXIT_SYM = + +# +# If this is specified it will be used by the link '-check' directive +# +NLM_CHECK_SYM = + +# +# If these are specified it will be used by the link '-flags' directive +# +NLM_FLAGS = + +# +# If this is specified it will be linked in with the XDCData option in the def +# file instead of the default of $(NWOS)/apache.xdc. XDCData can be disabled +# by setting APACHE_UNIPROC in the environment +# +XDCDATA = + +# +# If there is an NLM target, put it here +# +TARGET_nlm = \ + $(OBJDIR)/$(NLM_NAME).nlm \ + $(EOLIST) + +# +# If there is an LIB target, put it here +# +TARGET_lib = \ + $(OBJDIR)/lua.lib \ + $(EOLIST) + +# +# These are the OBJ files needed to create the NLM target above. +# Paths must all use the '/' character +# +FILES_nlm_objs = \ + $(OBJDIR)/mod_lua.o \ + $(OBJDIR)/lua_apr.o \ + $(OBJDIR)/lua_config.o \ + $(OBJDIR)/lua_passwd.o \ + $(OBJDIR)/lua_request.o \ + $(OBJDIR)/lua_vmprep.o \ + $(OBJDIR)/lua_dbd.o \ + $(OBJDIR)/libprews.o \ + $(EOLIST) + +# +# These are the LIB files needed to create the NLM target above. +# These will be added as a library command in the link.opt file. +# +FILES_nlm_libs = \ + $(PRELUDE) \ + $(OBJDIR)/lua.lib \ + $(EOLIST) + +# +# These are the modules that the above NLM target depends on to load. +# These will be added as a module command in the link.opt file. +# +FILES_nlm_modules = \ + aprlib \ + libc \ + $(EOLIST) + +# +# If the nlm has a msg file, put it's path here +# +FILE_nlm_msg = + +# +# If the nlm has a hlp file put it's path here +# +FILE_nlm_hlp = + +# +# If this is specified, it will override $(NWOS)\copyright.txt. +# +FILE_nlm_copyright = + +# +# Any additional imports go here +# +FILES_nlm_Ximports = \ + @aprlib.imp \ + @httpd.imp \ + @libc.imp \ + $(EOLIST) + +# Don't link with Winsock if standard sockets are being used +ifndef USE_STDSOCKETS +FILES_nlm_Ximports += @ws2nlm.imp \ + $(EOLIST) +endif + +# +# Any symbols exported to here +# +FILES_nlm_exports = \ + lua_module \ + $(EOLIST) + +# +# These are the OBJ files needed to create the LIB target above. +# Paths must all use the '/' character +# +UNWANTED = $(LUASRC)/src/lua.c $(LUASRC)/src/luac.c $(LUASRC)/src/print.c + +FILES_lib_objs = \ + $(patsubst $(LUASRC)/src/%.c,$(OBJDIR)/%.o, $(filter-out $(UNWANTED), $(wildcard $(LUASRC)/src/*.c))) \ + $(EOLIST) + +# +# implement targets and dependancies (leave this section alone) +# + +libs :: $(OBJDIR) $(TARGET_lib) + +nlms :: libs $(TARGET_nlm) + +# +# Updated this target to create necessary directories and copy files to the +# correct place. (See $(AP_WORK)/build/NWGNUhead.inc for examples) +# +install :: nlms FORCE + $(call COPY,$(OBJDIR)/*.nlm, $(INSTALLBASE)/modules/) + +# +# Any specialized rules here +# + +vpath %.c $(LUASRC)/src ../arch/netware + +# +# Include the 'tail' makefile that has targets that depend on variables defined +# in this makefile +# + +include $(APBUILD)/NWGNUtail.inc + + diff --git a/modules/lua/README b/modules/lua/README new file mode 100644 index 0000000..e0106e8 --- /dev/null +++ b/modules/lua/README @@ -0,0 +1,54 @@ +-*- mode:org -*- +* Requirements: +** lua 5.1, 5.2, 5.3 ( http://www.lua.org/ ) or LuaJIT 2.x ( http://www.luajit.org/ ) +** Apache HTTPD 2.4 ( http://httpd.apache.org/ ) or higher + +* Documentation + See docs/README + +* Building + For now, see docs/building-from-subversion.txt + + +* Task List +** TODO Use r->file to determine file, doing rewriting in translate_name +** TODO Provide means to get useful output from lua errors in response body + Probably have to put it on the vm spec for pre-handler errors, as + it is pre-handler, will prolly be on the request_config somewhere, + but sometimes cannot put there, so... fun +** TODO Mapping in the server_rec +** TODO Figure out how reentrancy works regarding filter chain stuff. + Do we need new "threads"? +** TODO: Flatten LuaHook* to LuaHook phase file fn ? +** TODO: document or remove block sections +** TODO: test per-dir behavior of block sections +** TODO: Suppress internal details (fs path to scripts, etc) in error responses +** TODO: Check whether we can tighten the mode flag in lua_load(), + luaL_loadfile() an dluaL_loadbuffer() from NULL (="bt") + to e.g. "t". + +* License + Apache License, Version 2.0, + + http://www.apache.org/licenses/LICENSE-2.0 + + See NOTICE file for more information + +* Problems and Patches: + Please use dev@httpd.apache.org for discussing mod_lua development + To subscribe send email to dev-subscribe@httpd.apache.org + Note that this is for development discussion, not user support :-) + +* Contributors Include +** Brian McCallister +** Paul Querna +** Garrett Rooney +** Martin Traverso +** Brian Akins +** Justin Erenkrantz +** Philip M. Gollucci +** Stefan Fritsch +** Eric Covener +** Daniel Gruno +** Günter Knauf +** Jim Jagielski diff --git a/modules/lua/config.m4 b/modules/lua/config.m4 new file mode 100644 index 0000000..29fd563 --- /dev/null +++ b/modules/lua/config.m4 @@ -0,0 +1,121 @@ + +APACHE_MODPATH_INIT(lua) + +dnl CHECK_LUA_PATH(PREFIX, INCLUDE-PATH, LIB-PATH, LIB-NAME) +dnl +dnl Checks for a specific version of the Lua libraries. Use CHECK_LUA instead, +dnl which will call this macro. +dnl +dnl Sets LUA_CFLAGS and LUA_LIBS, and breaks from its containing loop, if the +dnl check succeeds. +AC_DEFUN([CHECK_LUA_PATH], [dnl + AC_MSG_CHECKING([for lua.h in $1/$2]) + if test -f $1/$2/lua.h; then + AC_MSG_RESULT([yes]) + save_CFLAGS=$CFLAGS + save_LDFLAGS=$LDFLAGS + CFLAGS="$CFLAGS" + LDFLAGS="-L$1/$3 $LDFLAGS $lib_m" + AC_CHECK_LIB($4, luaL_newstate, [ + LUA_LIBS="-L$1/$3 -l$4 $lib_m" + if test "x$ap_platform_runtime_link_flag" != "x"; then + APR_ADDTO(LUA_LIBS, [$ap_platform_runtime_link_flag$1/$3]) + fi + LUA_CFLAGS="-I$1/$2" + ]) + CFLAGS=$save_CFLAGS + LDFLAGS=$save_LDFLAGS + + if test -n "${LUA_LIBS}"; then + break + fi + else + AC_MSG_RESULT([no]) + fi +]) + +dnl Check for Lua 5.3/5.2/5.1 Libraries +dnl CHECK_LUA(ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]) +dnl Sets: +dnl LUA_CFLAGS +dnl LUA_LIBS +AC_DEFUN([CHECK_LUA], +[dnl + +AC_ARG_WITH( + lua, + [AC_HELP_STRING([--with-lua=PATH],[Path to the Lua 5.3/5.2/5.1 prefix])], + lua_path="$withval", + :) + +dnl # Determine lua lib directory +if test -z "$lua_path"; then + test_paths=". /usr/local /usr" +else + test_paths="${lua_path}" +fi + +if test -n "$PKGCONFIG" -a -z "$lua_path" \ + && $PKGCONFIG --atleast-version=5.1 lua; then + LUA_LIBS="`$PKGCONFIG --libs lua`" + LUA_CFLAGS="`$PKGCONFIG --cflags lua`" + LUA_VERSION="`$PKGCONFIG --modversion lua`" + AC_MSG_NOTICE([using Lua $LUA_VERSION configuration from pkg-config]) +else + AC_CHECK_LIB(m, pow, lib_m="-lm") + AC_CHECK_LIB(m, sqrt, lib_m="-lm") + for x in $test_paths ; do + CHECK_LUA_PATH([${x}], [include/lua-5.3], [lib/lua-5.3], [lua-5.3]) + CHECK_LUA_PATH([${x}], [include/lua5.3], [lib], [lua5.3]) + CHECK_LUA_PATH([${x}], [include/lua53], [lib/lua53], [lua]) + + CHECK_LUA_PATH([${x}], [include], [lib], [lua]) + + CHECK_LUA_PATH([${x}], [include/lua-5.2], [lib/lua-5.2], [lua-5.2]) + CHECK_LUA_PATH([${x}], [include/lua5.2], [lib], [lua5.2]) + CHECK_LUA_PATH([${x}], [include/lua52], [lib/lua52], [lua]) + + CHECK_LUA_PATH([${x}], [include/lua-5.1], [lib/lua-5.1], [lua-5.1]) + CHECK_LUA_PATH([${x}], [include/lua5.1], [lib], [lua5.1]) + CHECK_LUA_PATH([${x}], [include/lua51], [lib/lua51], [lua]) + done +fi + +AC_SUBST(LUA_LIBS) +AC_SUBST(LUA_CFLAGS) + +if test -z "${LUA_LIBS}"; then + AC_MSG_WARN([*** Lua 5.3 5.2 or 5.1 library not found.]) + ifelse([$2], , + enable_lua="no" + if test -z "${lua_path}"; then + AC_MSG_WARN([Lua 5.3 5.2 or 5.1 library is required]) + else + AC_MSG_ERROR([Lua 5.3 5.2 or 5.1 library is required]) + fi, + $2) +else + AC_MSG_NOTICE([using '${LUA_LIBS}' for Lua Library]) + AC_ARG_ENABLE(luajit,APACHE_HELP_STRING(--enable-luajit,Enable LuaJit Support), + [ + if test "$enableval" = "yes"; then + APR_ADDTO(MOD_CPPFLAGS, ["-DAP_ENABLE_LUAJIT"]) + fi + ]) + ifelse([$1], , , $1) +fi +]) + +lua_objects="lua_apr.lo lua_config.lo mod_lua.lo lua_request.lo lua_vmprep.lo lua_dbd.lo lua_passwd.lo" + +APACHE_MODULE(lua, Apache Lua Framework, $lua_objects, , , [ + CHECK_LUA() + if test "x$enable_lua" != "xno" ; then + APR_ADDTO(MOD_INCLUDES, [$LUA_CFLAGS]) + APR_ADDTO(MOD_LUA_LDADD, [$LUA_LIBS $CRYPT_LIBS]) + fi +]) + +APR_ADDTO(INCLUDES, [-I\$(top_srcdir)/$modpath_current]) + +APACHE_MODPATH_FINISH diff --git a/modules/lua/docs/README b/modules/lua/docs/README new file mode 100644 index 0000000..632945a --- /dev/null +++ b/modules/lua/docs/README @@ -0,0 +1,12 @@ +Index of documents: + building-from-subversion.txt + Basic build instructions + + basic-configuration.txt + Getting mod_wombat up and running + + running-developer-tests.txt + How to set up and run the developer and regression tests + + writing-handlers.txt + basics on writing handlers in mod_wombat
\ No newline at end of file diff --git a/modules/lua/docs/basic-configuration.txt b/modules/lua/docs/basic-configuration.txt new file mode 100644 index 0000000..b837698 --- /dev/null +++ b/modules/lua/docs/basic-configuration.txt @@ -0,0 +1,141 @@ +See sample_httpd.conf for examples + +The basic module loading directive is + LoadModule lua_module modules/mod_lua.so + +The handler name is "lua-script" so you can use the normal +AddHandler directive, such as "AddHandler lua-script .lua" to +set anything ending in .lua to use mod_lua to evaluate + +mod_lua exports several additional directives: + + LuaRoot /path/to/a/directory + Specify the base path which will be used to evaluate all + relative paths within mod_lua. If not specified they + will be resolved relative to the current working directory, + which may not always work well for a server. + + LuaScope once|request|conn|server [max|min max] + Specify the lifecycle scope of the Lua interpreter which will + be used by handlers in this "Directory." The default is "once" + + once: use the interpreter once and throw it away. + + request: use the interpreter to handle anything based on + the same file within this request, which is also + request scoped. + + conn: Same as request but attached to the connection_rec + + server: This one is different than others because the + server scope is quite long lived, and multiple threads + will have the same server_rec. To accommodate this + server scoped interpreter are stored in an apr + resource list. The min and max arguments are intended + to specify the pool size, but are unused at this time. + + LuaMapHandler uri-pattern /path/to/lua/script.lua [function-name] + This directive matches a uri pattern to invoke a specific + handler function in a specific file. It uses PCRE regular + expressions to match the uri, and supports interpolating + match groups into both the file path and the function name + be careful writing your regular expressions to avoid security + issues. + + Examples: + LuaMapHandler /(\w+)/(/w+) /scripts/$1.lua handle_$2 + This would match uri's such as /photos/show?id=9 + to the file /scripts/photos.lua and invoke the + handler function handle_show on the lua vm after + loading that file. + + LuaMapHandler /bingo /scripts/wombat.lua + This would invoke the "handle" function, which + is the default if no specific function name is + provided. + + LuaPackagePath /path/to/include/?.lua + Add a path to lua's module search path. Follows the same + conventions as lua. This just munges the package.path in the + lua vms. + + Examples: + LuaPackagePath /scripts/lib/?.lua + LuaPackagePath /scripts/lib/?/init.lua + + LuaPackageCPath /path/to/include/?.soa + Add a path to lua's shared library search path. Follows the same + conventions as lua. This just munges the package.cpath in the + lua vms. + + Examples: + LuaPackagePath /scripts/lib/?.so + + LuaCodeCache stat|forever|never + Specify the behavior of the in-memory code cache. The default + is stat, which stats the top level script (not any included + ones) each time that file is needed, and reloads it if the + modified time indicates it is newer than the one it has + already loaded. The other values cause it to keep the file + cached forever (don't stat and replace) or to never cache the + file. + + In general stat or forever is good production and stat or never + for development. + + Examples: + LuaCodeCache stat + LuaCodeCache forever + LuaCodeCache never + + LuaHookTranslateName /path/to/lua/script.lua hook_function_name + Add a hook (at APR_HOOK_MIDDLE) to the translate name phase of + request processing. The hook function receives a single + argument, the request_rec, and should return a status code, + which is either an HTTP error code, or the constants defined + in the apache2 module: apache2.OK, apache2.DECLINED, or + apache2.DONE. + + For those new to hooks, basically each hook will be invoked + until one of them returns apache2.OK. If your hook doesn't + want to do the translation it should just return + apache2.DECLINED. If the request should stop processing, then + return apache2.DONE. + + Example: + LuaHookTranslateName /scripts/conf/hooks.lua silly_mapper + + -- /scripts/conf/hooks.lua -- + function silly_mapper(r) + if r.uri == "/" then + r.file = "/var/www/home.lua" + return apache2.OK + else + return apache2.DECLINED + end + end + + LuaHookFixups /path/to/lua/script.lua hook_function_name + Just like LuaHookTranslateName, but executed at the fixups phase + + LuaHookMapToStorage /path/to/lua/script.lua hook_function_name + ... + + LuaHookCheckUserID /path/to/lua/script.lua hook_function_name + ... + + LuaHookTypeChecker /path/to/lua/script.lua hook_function_name + ... + + LuaHookAuthChecker /path/to/lua/script.lua hook_function_name + ... + + LuaHookAccessChecker /path/to/lua/script.lua hook_function_name + ... + + LuaHookAuthChecker /path/to/lua/script.lua hook_function_name + ... + + LuaHookInsertFilter /path/to/lua/script.lua hook_function_name + Not Yet Implemented + diff --git a/modules/lua/docs/building-from-subversion.txt b/modules/lua/docs/building-from-subversion.txt new file mode 100644 index 0000000..98da7bf --- /dev/null +++ b/modules/lua/docs/building-from-subversion.txt @@ -0,0 +1,72 @@ +Install Lua 5.1 + http://www.lua.org/download.html + + Lua does not use autoconf for compiling. This means that you do not use + ./configure. It has good build instructions, though, so hopefully things + will go smoothly. + + I like to change the directory Lua installs to. In order to do this you + need to set LUA_TOP in the configuration makefile for Lua. For these + instructions I have set LUA_TOP to /Users/brianm/.opt/lua-5.1.2 -- you + will see this directory referred to later. + + +Install Apache HTTPD 2.2 + http://httpd.apache.org/download.cgi + + You can build apache pretty much any way you like, as long as you enable + dynamic module loading (--enable-so) so that mod_wombat can be loaded. + + You may user (and I encourage you to!) the threaded MPMs -- mod_wombat + plays nicely with them. + + I build it with these flags: + + ./configure --prefix=/Users/brianm/.opt/httpd-2.2.4-worker-wombat \ + --with-mpm=worker \ + --enable-so + + +Install libapreq2 + http://httpd.apache.org/apreq/download.cgi + The download link is in the page body, NOT under the "Download!" link + in the left hand column. + + Right now, mod_wombat requires libapreq2 for parsing entity bodies. This + dependency will probably be made optional in the near future, but for now + you need it. + + I build it with these flags: + + ./configure --prefix=/Users/brianm/.opt/libapreq2-2.0.8 \ + --with-apache2-apxs=/Users/brianm/.opt/httpd-2.2.4-worker-wombat/bin/apxs + + +Install mod_wombat from subversion + http://svn.apache.org/repos/asf/httpd/mod_wombat/trunk + + The first step, when building from subversion, is to bootstrap autoconf. + To do this run the bootstrap script: + + ./bootstrap + + The bootstrap script may report an error that it cannot find + libtoolize or glibtoolize. That is fine as long as it + doesn't report that it cannot find both of them. The script + just sets up the autoconf magic. + + After that, it is a normal configure and build: + + ./configure --with-lua=/Users/brianm/.opt/lua-5.1.2/ \ + --with-apxs=/Users/brianm/.opt/httpd-2.2.4-worker-wombat/bin/apxs \ + --with-apreq2=/Users/brianm/.opt/libapreq2-2.0.8/ + + If compiling (make) reports an error that it cannot find the + libapreq2 header file, please tell me ( brianm@apache.org ) + as this occurs under some configurations but we haven't + hammered down the weird things libapreq2 does with its + install. If you build libapreq2 with a --prefix configuration + option, it always seems to work. + + +That is it. To configure mod_wombat, look at the basic-configuration.txt document.
\ No newline at end of file diff --git a/modules/lua/docs/running-developer-tests.txt b/modules/lua/docs/running-developer-tests.txt new file mode 100644 index 0000000..59eb990 --- /dev/null +++ b/modules/lua/docs/running-developer-tests.txt @@ -0,0 +1,16 @@ +-*- mode:org -*- +* Building mod_lua + The first step is to build mod_lua per the instructions in + building-from-subversion.txt. + +* Build and install LuaSocket + http://www.cs.princeton.edu/~diego/professional/luasocket/ + FreeBSD: /usr/ports/net/luasocket + +* Running Tests + 1. Replace apache's httpd.conf with test/test_httpd.conf + 2. Customize the new httpd.conf to match your directories + 3. Finally, to run the tests, start apache and run: + $ cd test + $ lua ./test.lua + FreeBSD: lua-5.1 ./test.lua diff --git a/modules/lua/docs/writing-handlers.txt b/modules/lua/docs/writing-handlers.txt new file mode 100644 index 0000000..2f18c41 --- /dev/null +++ b/modules/lua/docs/writing-handlers.txt @@ -0,0 +1,49 @@ +mod_lua always looks to invoke a function for the handler, rather than +just evaluating a script body CGI style. A handler function looks +something like this: + + -- example.lua -- + require "string" + + function handle_something(r) + r.content_type = "text/plain" + r:puts("Hello Lua World!\n") + + if r.method == 'GET' then + for k, v in pairs( r:parseargs() ) do + r:puts( string.format("%s: %s", k, v) ) + end + elseif r.method == 'POST' then + for k, v in pairs( r:parsebody() ) do + r:puts( string.format("%s: %s", k, v) ) + end + else + r:puts("unknown HTTP method " .. r.method) + end + end + +This handler function just prints out the uri or form encoded +arguments to a plaintext page. + +This means (and in fact encourages) that you can have multiple +handlers (or hooks, or filters) in the same script. + +Data Structures: + request_rec: + the request_rec is mapped in as a userdata. It has a metatable + which lets you do useful things with it. For the most part it + has the same fields as the request_rec struct (see httpd.h + until we get better docs here) many of which are writeable as + well as readable, and has (at least) the following methods: + + r:puts("hello", " world", "!") -- print to response body + + -- logging functions + r:debug("This is a debug log message") + r:info("This is an info log message") + r:notice("This is an notice log message") + r:warn("This is an warn log message") + r:err("This is an err log message") + r:alert("This is an alert log message") + r:crit("This is an crit log message") + r:emerg("This is an emerg log message") diff --git a/modules/lua/lua_apr.c b/modules/lua/lua_apr.c new file mode 100644 index 0000000..8e34cf3 --- /dev/null +++ b/modules/lua/lua_apr.c @@ -0,0 +1,104 @@ +/** + * 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 "lua_apr.h" +APLOG_USE_MODULE(lua); + +req_table_t *ap_lua_check_apr_table(lua_State *L, int index) +{ + req_table_t* t; + luaL_checkudata(L, index, "Apr.Table"); + t = lua_unboxpointer(L, index); + return t; +} + + +void ap_lua_push_apr_table(lua_State *L, req_table_t *t) +{ + lua_boxpointer(L, t); + luaL_getmetatable(L, "Apr.Table"); + lua_setmetatable(L, -2); +} + +static int lua_table_set(lua_State *L) +{ + req_table_t *t = ap_lua_check_apr_table(L, 1); + const char *key = luaL_checkstring(L, 2); + const char *val = luaL_checkstring(L, 3); + /* Unless it's the 'notes' table, check for newline chars */ + /* t->r will be NULL in case of the connection notes, but since + we aren't going to check anything called 'notes', we can safely + disregard checking whether t->r is defined. + */ + if (strcmp(t->n, "notes") && ap_strchr_c(val, '\n')) { + char *badchar; + char *replacement = apr_pstrdup(t->r->pool, val); + badchar = replacement; + while ( (badchar = ap_strchr(badchar, '\n')) ) { + *badchar = ' '; + } + ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, t->r, APLOGNO(02614) + "mod_lua: Value for '%s' in table '%s' contains newline!", + key, t->n); + apr_table_set(t->t, key, replacement); + } + else { + apr_table_set(t->t, key, val); + } + return 0; +} + +static int lua_table_get(lua_State *L) +{ + req_table_t *t = ap_lua_check_apr_table(L, 1); + const char *key = luaL_checkstring(L, 2); + const char *val = apr_table_get(t->t, key); + lua_pushstring(L, val); + return 1; +} + +static const luaL_Reg lua_table_methods[] = { + {"set", lua_table_set}, + {"get", lua_table_get}, + {0, 0} +}; + + +int ap_lua_init(lua_State *L, apr_pool_t *p) +{ + luaL_newmetatable(L, "Apr.Table"); +#if LUA_VERSION_NUM < 502 + luaL_register(L, "apr_table", lua_table_methods); +#else + luaL_newlib(L, lua_table_methods); +#endif + lua_pushstring(L, "__index"); + lua_pushstring(L, "get"); + lua_gettable(L, 2); + lua_settable(L, 1); + + lua_pushstring(L, "__newindex"); + lua_pushstring(L, "set"); + lua_gettable(L, 2); + lua_settable(L, 1); + + return 0; +} + + + diff --git a/modules/lua/lua_apr.h b/modules/lua/lua_apr.h new file mode 100644 index 0000000..c194f11 --- /dev/null +++ b/modules/lua/lua_apr.h @@ -0,0 +1,36 @@ +/** + * 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. + */ + +#ifndef _LUA_APR_H_ +#define _LUA_APR_H_ + +#include "scoreboard.h" +#include "http_main.h" +#include "ap_mpm.h" +#include "apr_md5.h" +#include "apr_sha1.h" +#include "apr_poll.h" +#include "apr.h" +#include "apr_tables.h" +#include "apr_base64.h" + + +int ap_lua_init(lua_State *L, apr_pool_t * p); +req_table_t *ap_lua_check_apr_table(lua_State *L, int index); +void ap_lua_push_apr_table(lua_State *L, req_table_t *t); + +#endif /* !_LUA_APR_H_ */ diff --git a/modules/lua/lua_config.c b/modules/lua/lua_config.c new file mode 100644 index 0000000..14674a9 --- /dev/null +++ b/modules/lua/lua_config.c @@ -0,0 +1,277 @@ +/** + * 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 "lua_config.h" +#include "lua_vmprep.h" + +APLOG_USE_MODULE(lua); + +static ap_lua_dir_cfg *check_dir_config(lua_State *L, int index) +{ + ap_lua_dir_cfg *cfg; + luaL_checkudata(L, index, "Apache2.DirConfig"); + cfg = (ap_lua_dir_cfg *) lua_unboxpointer(L, index); + return cfg; +} + +static cmd_parms *check_cmd_parms(lua_State *L, int index) +{ + cmd_parms *cmd; + luaL_checkudata(L, index, "Apache2.CommandParameters"); + cmd = (cmd_parms *) lua_unboxpointer(L, index); + return cmd; +} + +static int apl_toscope(const char *name) +{ + if (0 == strcmp("once", name)) + return AP_LUA_SCOPE_ONCE; + if (0 == strcmp("request", name)) + return AP_LUA_SCOPE_REQUEST; + if (0 == strcmp("connection", name)) + return AP_LUA_SCOPE_CONN; + if (0 == strcmp("conn", name)) + return AP_LUA_SCOPE_CONN; + if (0 == strcmp("thread", name)) + return AP_LUA_SCOPE_THREAD; + return AP_LUA_SCOPE_ONCE; +} + +apr_status_t ap_lua_map_handler(ap_lua_dir_cfg *cfg, + const char *file, + const char *function, + const char *pattern, + const char *scope) +{ + ap_regex_t *uri_pattern; + apr_status_t rv; + ap_lua_mapped_handler_spec *handler = + apr_pcalloc(cfg->pool, sizeof(ap_lua_mapped_handler_spec)); + handler->uri_pattern = NULL; + handler->function_name = NULL; + + uri_pattern = apr_palloc(cfg->pool, sizeof(ap_regex_t)); + if ((rv = ap_regcomp(uri_pattern, pattern, 0)) != APR_SUCCESS) { + return rv; + } + handler->file_name = apr_pstrdup(cfg->pool, file); + handler->uri_pattern = uri_pattern; + handler->scope = apl_toscope(scope); + + handler->function_name = apr_pstrdup(cfg->pool, function); + *(const ap_lua_mapped_handler_spec **) apr_array_push(cfg->mapped_handlers) = + handler; + return APR_SUCCESS; +} + +/* Change to use ap_lua_map_handler */ +static int cfg_lua_map_handler(lua_State *L) +{ + ap_lua_dir_cfg *cfg = check_dir_config(L, 1); + ap_lua_mapped_handler_spec *handler = + apr_pcalloc(cfg->pool, sizeof(ap_lua_mapped_handler_spec)); + handler->uri_pattern = NULL; + handler->function_name = NULL; + + luaL_checktype(L, 2, LUA_TTABLE); + lua_getfield(L, 2, "file"); + if (lua_isstring(L, -1)) { + const char *file = lua_tostring(L, -1); + handler->file_name = apr_pstrdup(cfg->pool, file); + } + lua_pop(L, 1); + + lua_getfield(L, 2, "pattern"); + if (lua_isstring(L, -1)) { + const char *pattern = lua_tostring(L, -1); + + ap_regex_t *uri_pattern = apr_palloc(cfg->pool, sizeof(ap_regex_t)); + if (ap_regcomp(uri_pattern, pattern, 0) != OK) { + return luaL_error(L, "Unable to compile regular expression, '%s'", + pattern); + } + handler->uri_pattern = uri_pattern; + } + lua_pop(L, 1); + + lua_getfield(L, 2, "scope"); + if (lua_isstring(L, -1)) { + const char *scope = lua_tostring(L, -1); + handler->scope = apl_toscope(scope); + } + else { + handler->scope = AP_LUA_SCOPE_ONCE; + } + lua_pop(L, 1); + + lua_getfield(L, 2, "func"); + if (lua_isstring(L, -1)) { + const char *value = lua_tostring(L, -1); + handler->function_name = apr_pstrdup(cfg->pool, value); + } + else { + handler->function_name = "handle"; + } + lua_pop(L, 1); + + + *(const ap_lua_mapped_handler_spec **) apr_array_push(cfg->mapped_handlers) = + handler; + return 0; +} + +static int cfg_directory(lua_State *L) +{ + ap_lua_dir_cfg *cfg = check_dir_config(L, 1); + lua_pushstring(L, cfg->dir); + return 1; +} + +/*static int cfg_root(lua_State *L) +{ + ap_lua_dir_cfg *cfg = check_dir_config(L, 1); + lua_pushstring(L, cfg->root_path); + return 1; +}*/ + +static const struct luaL_Reg cfg_methods[] = { + {"match_handler", cfg_lua_map_handler}, + {"directory", cfg_directory}, + /* {"root", cfg_root}, */ + {NULL, NULL} +}; + +/* helper function for the logging functions below */ +static int cmd_log_at(lua_State *L, int level) +{ + const char *msg; + cmd_parms *cmd = check_cmd_parms(L, 1); + lua_Debug dbg; + + lua_getstack(L, 1, &dbg); + lua_getinfo(L, "Sl", &dbg); + + msg = luaL_checkstring(L, 2); + /* Intentional no APLOGNO */ + ap_log_error(dbg.source, dbg.currentline, APLOG_MODULE_INDEX, level, 0, + cmd->server, "%s", msg); + return 0; +} + +/* r:debug(String) and friends which use apache logging */ +static int cmd_emerg(lua_State *L) +{ + return cmd_log_at(L, APLOG_EMERG); +} +static int cmd_alert(lua_State *L) +{ + return cmd_log_at(L, APLOG_ALERT); +} +static int cmd_crit(lua_State *L) +{ + return cmd_log_at(L, APLOG_CRIT); +} +static int cmd_err(lua_State *L) +{ + return cmd_log_at(L, APLOG_ERR); +} +static int cmd_warn(lua_State *L) +{ + return cmd_log_at(L, APLOG_WARNING); +} +static int cmd_notice(lua_State *L) +{ + return cmd_log_at(L, APLOG_NOTICE); +} +static int cmd_info(lua_State *L) +{ + return cmd_log_at(L, APLOG_INFO); +} +static int cmd_debug(lua_State *L) +{ + return cmd_log_at(L, APLOG_DEBUG); +} +static int cmd_trace1(lua_State *L) +{ + return cmd_log_at(L, APLOG_TRACE1); +} +static int cmd_trace2(lua_State *L) +{ + return cmd_log_at(L, APLOG_TRACE2); +} +static int cmd_trace3(lua_State *L) +{ + return cmd_log_at(L, APLOG_TRACE3); +} +static int cmd_trace4(lua_State *L) +{ + return cmd_log_at(L, APLOG_TRACE4); +} +static int cmd_trace5(lua_State *L) +{ + return cmd_log_at(L, APLOG_TRACE5); +} +static int cmd_trace6(lua_State *L) +{ + return cmd_log_at(L, APLOG_TRACE6); +} +static int cmd_trace7(lua_State *L) +{ + return cmd_log_at(L, APLOG_TRACE7); +} +static int cmd_trace8(lua_State *L) +{ + return cmd_log_at(L, APLOG_TRACE8); +} + +static const struct luaL_Reg cmd_methods[] = { + {"trace8", cmd_trace8}, + {"trace7", cmd_trace7}, + {"trace6", cmd_trace6}, + {"trace5", cmd_trace5}, + {"trace4", cmd_trace4}, + {"trace3", cmd_trace3}, + {"trace2", cmd_trace2}, + {"trace1", cmd_trace1}, + {"debug", cmd_debug}, + {"info", cmd_info}, + {"notice", cmd_notice}, + {"warn", cmd_warn}, + {"err", cmd_err}, + {"crit", cmd_crit}, + {"alert", cmd_alert}, + {"emerg", cmd_emerg}, + + {NULL, NULL} +}; + +void ap_lua_load_config_lmodule(lua_State *L) +{ + luaL_newmetatable(L, "Apache2.DirConfig"); /* [metatable] */ + lua_pushvalue(L, -1); + + lua_setfield(L, -2, "__index"); + luaL_setfuncs_compat(L, cfg_methods); /* [metatable] */ + + + luaL_newmetatable(L, "Apache2.CommandParameters"); + lua_pushvalue(L, -1); + + lua_setfield(L, -2, "__index"); + luaL_setfuncs_compat(L, cmd_methods); /* [metatable] */ + +} diff --git a/modules/lua/lua_config.h b/modules/lua/lua_config.h new file mode 100644 index 0000000..8a778ad --- /dev/null +++ b/modules/lua/lua_config.h @@ -0,0 +1,31 @@ +/** + * 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" + +#ifndef _APL_CONFIG_H_ +#define _APL_CONFIG_H_ + +void ap_lua_load_config_lmodule(lua_State *L); + +apr_status_t ap_lua_map_handler(ap_lua_dir_cfg *cfg, + const char *file, + const char *function, + const char *pattern, + const char *scope); + +#endif /* !_APL_CONFIG_H_ */ diff --git a/modules/lua/lua_dbd.c b/modules/lua/lua_dbd.c new file mode 100644 index 0000000..1b8d5b7 --- /dev/null +++ b/modules/lua/lua_dbd.c @@ -0,0 +1,843 @@ +/** + * 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 "lua_dbd.h" + +APLOG_USE_MODULE(lua); +static APR_OPTIONAL_FN_TYPE(ap_dbd_close) *lua_ap_dbd_close = NULL; +static APR_OPTIONAL_FN_TYPE(ap_dbd_open) *lua_ap_dbd_open = NULL; + + + + +static request_rec *ap_lua_check_request_rec(lua_State *L, int index) +{ + request_rec *r; + luaL_checkudata(L, index, "Apache2.Request"); + r = lua_unboxpointer(L, index); + return r; +} + +static lua_db_handle *lua_get_db_handle(lua_State *L) +{ + luaL_checktype(L, 1, LUA_TTABLE); + lua_rawgeti(L, 1, 0); + luaL_checktype(L, -1, LUA_TUSERDATA); + return (lua_db_handle *) lua_topointer(L, -1); +} + +static lua_db_result_set *lua_get_result_set(lua_State *L) +{ + luaL_checktype(L, 1, LUA_TTABLE); + lua_rawgeti(L, 1, 0); + luaL_checktype(L, -1, LUA_TUSERDATA); + return (lua_db_result_set *) lua_topointer(L, -1); +} + + +/* + ============================================================================= + db:close(): Closes an open database connection. + ============================================================================= + */ +int lua_db_close(lua_State *L) +{ + /*~~~~~~~~~~~~~~~~~~~~*/ + lua_db_handle *db; + apr_status_t rc = 0; + /*~~~~~~~~~~~~~~~~~~~~*/ + + db = lua_get_db_handle(L); + if (db && db->alive) { + if (db->type == LUA_DBTYPE_APR_DBD) { + rc = apr_dbd_close(db->driver, db->handle); + if (db->pool) apr_pool_destroy(db->pool); + } + else { + lua_ap_dbd_close = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_close); + if (lua_ap_dbd_close != NULL) + if (db->dbdhandle) lua_ap_dbd_close(db->server, db->dbdhandle); + } + + db->driver = NULL; + db->handle = NULL; + db->alive = 0; + db->pool = NULL; + } + + lua_settop(L, 0); + lua_pushnumber(L, rc); + return 1; +} + +/* + ============================================================================= + db:__gc(): Garbage collecting function. + ============================================================================= + */ +int lua_db_gc(lua_State *L) +{ + /*~~~~~~~~~~~~~~~~*/ + lua_db_handle *db; + /*~~~~~~~~~~~~~~~~~~~~*/ + + db = lua_touserdata(L, 1); + if (db && db->alive) { + if (db->type == LUA_DBTYPE_APR_DBD) { + apr_dbd_close(db->driver, db->handle); + if (db->pool) apr_pool_destroy(db->pool); + } + else { + lua_ap_dbd_close = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_close); + if (lua_ap_dbd_close != NULL) + if (db->dbdhandle) lua_ap_dbd_close(db->server, db->dbdhandle); + } + db->driver = NULL; + db->handle = NULL; + db->alive = 0; + db->pool = NULL; + } + lua_settop(L, 0); + return 0; +} + +/* + ============================================================================= + db:active(): Returns true if the connection to the db is still active. + ============================================================================= + */ +int lua_db_active(lua_State *L) +{ + /*~~~~~~~~~~~~~~~~~~~~*/ + lua_db_handle *db = 0; + apr_status_t rc = 0; + /*~~~~~~~~~~~~~~~~~~~~*/ + + db = lua_get_db_handle(L); + if (db && db->alive) { + rc = apr_dbd_check_conn(db->driver, db->pool, db->handle); + if (rc == APR_SUCCESS) { + lua_pushboolean(L, 1); + return 1; + } + } + + lua_pushboolean(L, 0); + return 1; +} + +/* + ============================================================================= + db:query(statement): Executes the given database query and returns the + number of rows affected. If an error is encountered, returns nil as the + first parameter and the error message as the second. + ============================================================================= + */ +int lua_db_query(lua_State *L) +{ + /*~~~~~~~~~~~~~~~~~~~~~~~*/ + lua_db_handle *db = 0; + apr_status_t rc = 0; + int x = 0; + const char *statement; + /*~~~~~~~~~~~~~~~~~~~~~~~*/ + luaL_checktype(L, 3, LUA_TSTRING); + statement = lua_tostring(L, 3); + db = lua_get_db_handle(L); + if (db && db->alive) + rc = apr_dbd_query(db->driver, db->handle, &x, statement); + else { + rc = 0; + x = -1; + } + + if (rc == APR_SUCCESS) + lua_pushnumber(L, x); + else { + + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + const char *err = apr_dbd_error(db->driver, db->handle, rc); + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + + lua_pushnil(L); + if (err) { + lua_pushstring(L, err); + return 2; + } + } + + return 1; +} + +/* + ============================================================================= + db:escape(string): Escapes a string for safe use in the given database type. + ============================================================================= + */ +int lua_db_escape(lua_State *L) +{ + /*~~~~~~~~~~~~~~~~~~~~~*/ + lua_db_handle *db = 0; + const char *statement; + const char *escaped = 0; + request_rec *r; + /*~~~~~~~~~~~~~~~~~~~~~*/ + + r = ap_lua_check_request_rec(L, 2); + if (r) { + luaL_checktype(L, 3, LUA_TSTRING); + statement = lua_tostring(L, 3); + db = lua_get_db_handle(L); + if (db && db->alive) { + apr_dbd_init(r->pool); + escaped = apr_dbd_escape(db->driver, r->pool, statement, + db->handle); + if (escaped) { + lua_pushstring(L, escaped); + return 1; + } + } + else { + lua_pushnil(L); + } + return (1); + } + + return 0; +} + +/* + ============================================================================= + resultset(N): Fetches one or more rows from a result set. + ============================================================================= + */ +int lua_db_get_row(lua_State *L) +{ + int row_no,x,alpha = 0; + const char *entry, *rowname; + apr_dbd_row_t *row = 0; + lua_db_result_set *res = lua_get_result_set(L); + + row_no = luaL_optinteger(L, 2, 0); + if (lua_isboolean(L, 3)) { + alpha = lua_toboolean(L, 3); + } + lua_settop(L,0); + + /* Fetch all rows at once? */ + + if (row_no == 0) { + row_no = 1; + lua_newtable(L); + while (apr_dbd_get_row(res->driver, res->pool, res->results, + &row, -1) != -1) + { + lua_pushinteger(L, row_no); + lua_newtable(L); + for (x = 0; x < res->cols; x++) { + entry = apr_dbd_get_entry(res->driver, row, x); + if (entry) { + if (alpha == 1) { + rowname = apr_dbd_get_name(res->driver, + res->results, x); + lua_pushstring(L, rowname ? rowname : "(oob)"); + } + else { + lua_pushinteger(L, x + 1); + } + lua_pushstring(L, entry); + lua_rawset(L, -3); + } + } + lua_rawset(L, -3); + row_no++; + } + return 1; + } + + /* Just fetch a single row */ + if (apr_dbd_get_row(res->driver, res->pool, res->results, + &row, row_no) != -1) + { + + lua_newtable(L); + for (x = 0; x < res->cols; x++) { + entry = apr_dbd_get_entry(res->driver, row, x); + if (entry) { + if (alpha == 1) { + rowname = apr_dbd_get_name(res->driver, + res->results, x); + lua_pushstring(L, rowname ? rowname : "(oob)"); + } + else { + lua_pushinteger(L, x + 1); + } + lua_pushstring(L, entry); + lua_rawset(L, -3); + } + } + return 1; + } + return 0; +} + + +/* + ============================================================================= + db:select(statement): Queries the database for the given statement and + returns the rows/columns found as a table. If an error is encountered, + returns nil as the first parameter and the error message as the second. + ============================================================================= + */ +int lua_db_select(lua_State *L) +{ + /*~~~~~~~~~~~~~~~~~~~~~~~*/ + lua_db_handle *db = 0; + apr_status_t rc = 0; + const char *statement; + request_rec *r; + /*~~~~~~~~~~~~~~~~~~~~~~~*/ + r = ap_lua_check_request_rec(L, 2); + if (r) { + luaL_checktype(L, 3, LUA_TSTRING); + statement = lua_tostring(L, 3); + db = lua_get_db_handle(L); + if (db && db->alive) { + + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + int cols; + apr_dbd_results_t *results = 0; + lua_db_result_set* resultset = NULL; + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + + rc = apr_dbd_select(db->driver, db->pool, db->handle, + &results, statement, 0); + if (rc == APR_SUCCESS) { + + cols = apr_dbd_num_cols(db->driver, results); + + if (cols > 0) { + lua_newtable(L); + resultset = lua_newuserdata(L, sizeof(lua_db_result_set)); + resultset->cols = cols; + resultset->driver = db->driver; + resultset->pool = db->pool; + resultset->rows = apr_dbd_num_tuples(db->driver, results); + resultset->results = results; + luaL_newmetatable(L, "lua_apr.dbselect"); + lua_pushliteral(L, "__call"); + lua_pushcfunction(L, lua_db_get_row); + lua_rawset(L, -3); + lua_setmetatable(L, -3); + lua_rawseti(L, -2, 0); + return 1; + } + return 0; + } + else { + + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + const char *err = apr_dbd_error(db->driver, db->handle, rc); + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + + lua_pushnil(L); + if (err) { + lua_pushstring(L, err); + return 2; + } + } + } + + lua_pushboolean(L, 0); + return 1; + } + + return 0; +} + + + +/* + ============================================================================= + statement:select(var1, var2, var3...): Injects variables into a prepared + statement and returns the number of rows matching the query. + ============================================================================= + */ +int lua_db_prepared_select(lua_State *L) +{ + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + lua_db_prepared_statement *st = 0; + apr_status_t rc = 0; + const char **vars; + int x, have; + /*~~~~~~~~~~~~~~~~~~~~~~~*/ + + /* Fetch the prepared statement and the vars passed */ + luaL_checktype(L, 1, LUA_TTABLE); + lua_rawgeti(L, 1, 0); + luaL_checktype(L, -1, LUA_TUSERDATA); + st = (lua_db_prepared_statement*) lua_topointer(L, -1); + + /* Check if we got enough variables passed on to us. + * This, of course, only works for prepared statements made through lua. */ + have = lua_gettop(L) - 2; + if (st->variables != -1 && have < st->variables ) { + lua_pushboolean(L, 0); + lua_pushfstring(L, + "Error in executing prepared statement: Expected %d arguments, got %d.", + st->variables, have); + return 2; + } + vars = apr_pcalloc(st->db->pool, have*sizeof(char *)); + for (x = 0; x < have; x++) { + vars[x] = lua_tostring(L, x + 2); + } + + /* Fire off the query */ + if (st->db && st->db->alive) { + + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + int cols; + apr_dbd_results_t *results = 0; + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + + rc = apr_dbd_pselect(st->db->driver, st->db->pool, st->db->handle, + &results, st->statement, 0, have, vars); + if (rc == APR_SUCCESS) { + + /*~~~~~~~~~~~~~~~~~~~~~*/ + lua_db_result_set *resultset; + /*~~~~~~~~~~~~~~~~~~~~~*/ + + cols = apr_dbd_num_cols(st->db->driver, results); + lua_newtable(L); + resultset = lua_newuserdata(L, sizeof(lua_db_result_set)); + resultset->cols = cols; + resultset->driver = st->db->driver; + resultset->pool = st->db->pool; + resultset->rows = apr_dbd_num_tuples(st->db->driver, results); + resultset->results = results; + luaL_newmetatable(L, "lua_apr.dbselect"); + lua_pushliteral(L, "__call"); + lua_pushcfunction(L, lua_db_get_row); + lua_rawset(L, -3); + lua_setmetatable(L, -3); + lua_rawseti(L, -2, 0); + return 1; + + } + else { + + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + const char *err = apr_dbd_error(st->db->driver, st->db->handle, rc); + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + + lua_pushnil(L); + if (err) { + lua_pushstring(L, err); + return 2; + } + return 1; + } + } + + lua_pushboolean(L, 0); + lua_pushliteral(L, + "Database connection seems to be closed, please reacquire it."); + return (2); +} + + +/* + ============================================================================= + statement:query(var1, var2, var3...): Injects variables into a prepared + statement and returns the number of rows affected. + ============================================================================= + */ +int lua_db_prepared_query(lua_State *L) +{ + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + lua_db_prepared_statement *st = 0; + apr_status_t rc = 0; + const char **vars; + int x, have; + /*~~~~~~~~~~~~~~~~~~~~~~~*/ + + /* Fetch the prepared statement and the vars passed */ + luaL_checktype(L, 1, LUA_TTABLE); + lua_rawgeti(L, 1, 0); + luaL_checktype(L, -1, LUA_TUSERDATA); + st = (lua_db_prepared_statement*) lua_topointer(L, -1); + + /* Check if we got enough variables passed on to us. + * This, of course, only works for prepared statements made through lua. */ + have = lua_gettop(L) - 2; + if (st->variables != -1 && have < st->variables ) { + lua_pushboolean(L, 0); + lua_pushfstring(L, + "Error in executing prepared statement: Expected %d arguments, got %d.", + st->variables, have); + return 2; + } + vars = apr_pcalloc(st->db->pool, have*sizeof(char *)); + for (x = 0; x < have; x++) { + vars[x] = lua_tostring(L, x + 2); + } + + /* Fire off the query */ + if (st->db && st->db->alive) { + + /*~~~~~~~~~~~~~~*/ + int affected = 0; + /*~~~~~~~~~~~~~~*/ + + rc = apr_dbd_pquery(st->db->driver, st->db->pool, st->db->handle, + &affected, st->statement, have, vars); + if (rc == APR_SUCCESS) { + lua_pushinteger(L, affected); + return 1; + } + else { + + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + const char *err = apr_dbd_error(st->db->driver, st->db->handle, rc); + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + + lua_pushnil(L); + if (err) { + lua_pushstring(L, err); + return 2; + } + return 1; + } + } + + lua_pushboolean(L, 0); + lua_pushliteral(L, + "Database connection seems to be closed, please reacquire it."); + return (2); +} + +/* + ============================================================================= + db:prepare(statement): Prepares a statement for later query/select. + Returns a table with a :query and :select function, same as the db funcs. + ============================================================================= + */ +int lua_db_prepare(lua_State* L) +{ + /*~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + lua_db_handle *db = 0; + apr_status_t rc = 0; + const char *statement, *at; + request_rec *r; + lua_db_prepared_statement* st; + int need = 0; + /*~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + + r = ap_lua_check_request_rec(L, 2); + if (r) { + apr_dbd_prepared_t *pstatement = NULL; + luaL_checktype(L, 3, LUA_TSTRING); + statement = lua_tostring(L, 3); + + /* Count number of variables in statement */ + at = ap_strchr_c(statement,'%'); + while (at != NULL) { + if (at[1] == '%') { + at++; + } + else { + need++; + } + at = ap_strchr_c(at+1,'%'); + } + + + db = lua_get_db_handle(L); + rc = apr_dbd_prepare(db->driver, r->pool, db->handle, statement, + NULL, &pstatement); + if (rc != APR_SUCCESS) { + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + const char *err = apr_dbd_error(db->driver, db->handle, rc); + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + + lua_pushnil(L); + if (err) { + lua_pushstring(L, err); + return 2; + } + return 1; + } + + /* Push the prepared statement table */ + lua_newtable(L); + st = lua_newuserdata(L, sizeof(lua_db_prepared_statement)); + st->statement = pstatement; + st->variables = need; + st->db = db; + + lua_pushliteral(L, "select"); + lua_pushcfunction(L, lua_db_prepared_select); + lua_rawset(L, -4); + lua_pushliteral(L, "query"); + lua_pushcfunction(L, lua_db_prepared_query); + lua_rawset(L, -4); + lua_rawseti(L, -2, 0); + return 1; + } + return 0; +} + + + +/* + ============================================================================= + db:prepared(statement): Fetches a prepared statement made through + DBDPrepareSQL. + ============================================================================= + */ +int lua_db_prepared(lua_State* L) +{ + /*~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + lua_db_handle *db = 0; + const char *tag; + request_rec *r; + lua_db_prepared_statement* st; + /*~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + + r = ap_lua_check_request_rec(L, 2); + if (r) { + apr_dbd_prepared_t *pstatement = NULL; + db = lua_get_db_handle(L); + luaL_checktype(L, 3, LUA_TSTRING); + tag = lua_tostring(L, 3); + + /* Look for the statement */ + pstatement = apr_hash_get(db->dbdhandle->prepared, tag, + APR_HASH_KEY_STRING); + + if (pstatement == NULL) { + lua_pushnil(L); + lua_pushfstring(L, + "Could not find any prepared statement called %s!", tag); + return 2; + } + + + /* Push the prepared statement table */ + lua_newtable(L); + st = lua_newuserdata(L, sizeof(lua_db_prepared_statement)); + st->statement = pstatement; + st->variables = -1; /* we don't know :( */ + st->db = db; + lua_pushliteral(L, "select"); + lua_pushcfunction(L, lua_db_prepared_select); + lua_rawset(L, -4); + lua_pushliteral(L, "query"); + lua_pushcfunction(L, lua_db_prepared_query); + lua_rawset(L, -4); + lua_rawseti(L, -2, 0); + return 1; + } + return 0; +} + + + +/* lua_push_db_handle: Creates a database table object with database functions + and a userdata at index 0, which will call lua_dbgc when garbage collected. + */ +static lua_db_handle* lua_push_db_handle(lua_State *L, request_rec* r, int type, + apr_pool_t* pool) +{ + lua_db_handle* db; + lua_newtable(L); + db = lua_newuserdata(L, sizeof(lua_db_handle)); + db->alive = 1; + db->pool = pool; + db->type = type; + db->dbdhandle = 0; + db->server = r->server; + luaL_newmetatable(L, "lua_apr.dbacquire"); + lua_pushliteral(L, "__gc"); + lua_pushcfunction(L, lua_db_gc); + lua_rawset(L, -3); + lua_setmetatable(L, -2); + lua_rawseti(L, -2, 0); + + lua_pushliteral(L, "escape"); + lua_pushcfunction(L, lua_db_escape); + lua_rawset(L, -3); + + lua_pushliteral(L, "close"); + lua_pushcfunction(L, lua_db_close); + lua_rawset(L, -3); + + lua_pushliteral(L, "select"); + lua_pushcfunction(L, lua_db_select); + lua_rawset(L, -3); + + lua_pushliteral(L, "query"); + lua_pushcfunction(L, lua_db_query); + lua_rawset(L, -3); + + lua_pushliteral(L, "active"); + lua_pushcfunction(L, lua_db_active); + lua_rawset(L, -3); + + lua_pushliteral(L, "prepare"); + lua_pushcfunction(L, lua_db_prepare); + lua_rawset(L, -3); + + lua_pushliteral(L, "prepared"); + lua_pushcfunction(L, lua_db_prepared); + lua_rawset(L, -3); + return db; +} + +/* + ============================================================================= + dbacquire(dbType, dbString): Opens a new connection to a database of type + _dbType_ and with the connection parameters _dbString_. If successful, + returns a table with functions for using the database handle. If an error + occurs, returns nil as the first parameter and the error message as the + second. See the APR_DBD for a list of database types and connection strings + supported. + ============================================================================= + */ +int lua_db_acquire(lua_State *L) +{ + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + const char *type; + const char *arguments; + const char *error = 0; + request_rec *r; + lua_db_handle *db = 0; + apr_status_t rc = 0; + ap_dbd_t *dbdhandle = NULL; + apr_pool_t *pool = NULL; + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + + r = ap_lua_check_request_rec(L, 1); + if (r) { + type = luaL_optstring(L, 2, "mod_dbd"); /* Defaults to mod_dbd */ + + if (!strcmp(type, "mod_dbd")) { + + lua_settop(L, 0); + lua_ap_dbd_open = APR_RETRIEVE_OPTIONAL_FN(ap_dbd_open); + if (lua_ap_dbd_open) + dbdhandle = (ap_dbd_t *) lua_ap_dbd_open( + r->server->process->pool, r->server); + + if (dbdhandle) { + db = lua_push_db_handle(L, r, LUA_DBTYPE_MOD_DBD, dbdhandle->pool); + db->driver = dbdhandle->driver; + db->handle = dbdhandle->handle; + db->dbdhandle = dbdhandle; + return 1; + } + else { + lua_pushnil(L); + if ( lua_ap_dbd_open == NULL ) + lua_pushliteral(L, + "mod_dbd doesn't seem to have been loaded."); + else + lua_pushliteral( + L, + "Could not acquire connection from mod_dbd. If your database is running, this may indicate a permission problem."); + return 2; + } + } + else { + rc = apr_pool_create(&pool, NULL); + if (rc != APR_SUCCESS) { + lua_pushnil(L); + lua_pushliteral(L, "Could not allocate memory for database!"); + return 2; + } + apr_pool_tag(pool, "lua_dbd_pool"); + apr_dbd_init(pool); + dbdhandle = apr_pcalloc(pool, sizeof(ap_dbd_t)); + rc = apr_dbd_get_driver(pool, type, &dbdhandle->driver); + if (rc == APR_SUCCESS) { + luaL_checktype(L, 3, LUA_TSTRING); + arguments = lua_tostring(L, 3); + lua_settop(L, 0); + + if (*arguments) { + rc = apr_dbd_open_ex(dbdhandle->driver, pool, + arguments, &dbdhandle->handle, &error); + if (rc == APR_SUCCESS) { + db = lua_push_db_handle(L, r, LUA_DBTYPE_APR_DBD, pool); + db->driver = dbdhandle->driver; + db->handle = dbdhandle->handle; + db->dbdhandle = dbdhandle; + return 1; + } + else { + lua_pushnil(L); + if (error) { + lua_pushstring(L, error); + return 2; + } + + return 1; + } + } + + lua_pushnil(L); + lua_pushliteral(L, + "No database connection string was specified."); + apr_pool_destroy(pool); + return (2); + } + else { + lua_pushnil(L); + if (APR_STATUS_IS_ENOTIMPL(rc)) { + lua_pushfstring(L, + "driver for %s not available", type); + } + else if (APR_STATUS_IS_EDSOOPEN(rc)) { + lua_pushfstring(L, + "can't find driver for %s", type); + } + else if (APR_STATUS_IS_ESYMNOTFOUND(rc)) { + lua_pushfstring(L, + "driver for %s is invalid or corrupted", + type); + } + else { + lua_pushliteral(L, + "mod_lua not compatible with APR in get_driver"); + } + lua_pushinteger(L, rc); + apr_pool_destroy(pool); + return 3; + } + } + + lua_pushnil(L); + return 1; + } + + return 0; +} + diff --git a/modules/lua/lua_dbd.h b/modules/lua/lua_dbd.h new file mode 100644 index 0000000..566204b --- /dev/null +++ b/modules/lua/lua_dbd.h @@ -0,0 +1,66 @@ +/** + * 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. + */ + +#ifndef _LUA_DBD_H_ +#define _LUA_DBD_H_ + +#include "mod_lua.h" +#include "apr.h" +#include "apr_dbd.h" +#include "mod_dbd.h" + +#define LUA_DBTYPE_APR_DBD 0 +#define LUA_DBTYPE_MOD_DBD 1 +typedef struct +{ + apr_dbd_t *handle; + const apr_dbd_driver_t *driver; + int alive; + apr_pool_t *pool; + char type; + ap_dbd_t * dbdhandle; + server_rec *server; +} lua_db_handle; + +typedef struct { + const apr_dbd_driver_t *driver; + int rows; + int cols; + apr_dbd_results_t *results; + apr_pool_t *pool; +} lua_db_result_set; + +typedef struct { + apr_dbd_prepared_t *statement; + int variables; + lua_db_handle *db; +} lua_db_prepared_statement; + +int lua_db_acquire(lua_State* L); +int lua_db_escape(lua_State* L); +int lua_db_close(lua_State* L); +int lua_db_prepare(lua_State* L); +int lua_db_prepared(lua_State* L); +int lua_db_select(lua_State* L); +int lua_db_query(lua_State* L); +int lua_db_prepared_select(lua_State* L); +int lua_db_prepared_query(lua_State* L); +int lua_db_get_row(lua_State* L); +int lua_db_gc(lua_State* L); +int lua_db_active(lua_State* L); + +#endif /* !_LUA_DBD_H_ */ diff --git a/modules/lua/lua_passwd.c b/modules/lua/lua_passwd.c new file mode 100644 index 0000000..ad86536 --- /dev/null +++ b/modules/lua/lua_passwd.c @@ -0,0 +1,178 @@ +/* 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 "lua_passwd.h" +#include "apr_strings.h" +#include "apr_errno.h" + +#if APR_HAVE_STDIO_H +#include <stdio.h> +#endif + +#include "apr_md5.h" +#include "apr_sha1.h" + +#if APR_HAVE_TIME_H +#include <time.h> +#endif +#if APR_HAVE_CRYPT_H +#include <crypt.h> +#endif +#if APR_HAVE_STDLIB_H +#include <stdlib.h> +#endif +#if APR_HAVE_STRING_H +#include <string.h> +#endif +#if APR_HAVE_UNISTD_H +#include <unistd.h> +#endif +#if APR_HAVE_IO_H +#include <io.h> +#endif + +static int generate_salt(char *s, size_t size, const char **errstr, + apr_pool_t *pool) +{ + unsigned char rnd[32]; + static const char itoa64[] = + "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; + apr_size_t n; + unsigned int val = 0, bits = 0; + apr_status_t rv; + + n = (size * 6 + 7)/8; + if (n > sizeof(rnd)) { + *errstr = apr_psprintf(pool, "generate_salt(): BUG: Buffer too small"); + return ERR_RANDOM; + } + rv = apr_generate_random_bytes(rnd, n); + if (rv) { + *errstr = apr_psprintf(pool, "Unable to generate random bytes: %pm", + &rv); + return ERR_RANDOM; + } + n = 0; + while (size > 0) { + if (bits < 6) { + val |= (rnd[n++] << bits); + bits += 8; + } + *s++ = itoa64[val & 0x3f]; + size--; + val >>= 6; + bits -= 6; + } + *s = '\0'; + return 0; +} + +/* + * Make a password record from the given information. A zero return + * indicates success; on failure, ctx->errstr points to the error message. + */ +int mk_password_hash(passwd_ctx *ctx) +{ + char *pw; + char salt[16]; + apr_status_t rv; + int ret = 0; +#if CRYPT_ALGO_SUPPORTED + char *cbuf; +#endif + + pw = ctx->passwd; + switch (ctx->alg) { + case ALG_APSHA: + /* XXX out >= 28 + strlen(sha1) chars - fixed len SHA */ + apr_sha1_base64(pw, strlen(pw), ctx->out); + break; + + case ALG_APMD5: + ret = generate_salt(salt, 8, &ctx->errstr, ctx->pool); + if (ret != 0) { + ret = ERR_GENERAL; + break; + } + rv = apr_md5_encode(pw, salt, ctx->out, ctx->out_len); + if (rv != APR_SUCCESS) { + ctx->errstr = apr_psprintf(ctx->pool, + "could not encode password: %pm", &rv); + ret = ERR_GENERAL; + } + break; + +#if CRYPT_ALGO_SUPPORTED + case ALG_CRYPT: + ret = generate_salt(salt, 8, &ctx->errstr, ctx->pool); + if (ret != 0) + break; + cbuf = crypt(pw, salt); + if (cbuf == NULL) { + rv = APR_FROM_OS_ERROR(errno); + ctx->errstr = apr_psprintf(ctx->pool, "crypt() failed: %pm", &rv); + ret = ERR_PWMISMATCH; + break; + } + + apr_cpystrn(ctx->out, cbuf, ctx->out_len - 1); + if (strlen(pw) > 8) { + char *truncpw = apr_pstrdup(ctx->pool, pw); + truncpw[8] = '\0'; + if (!strcmp(ctx->out, crypt(truncpw, salt))) { + ctx->errstr = apr_psprintf(ctx->pool, + "Warning: Password truncated to 8 " + "characters by CRYPT algorithm."); + } + memset(truncpw, '\0', strlen(pw)); + } + break; +#endif /* CRYPT_ALGO_SUPPORTED */ + +#if BCRYPT_ALGO_SUPPORTED + case ALG_BCRYPT: + rv = apr_generate_random_bytes((unsigned char*)salt, 16); + if (rv != APR_SUCCESS) { + ctx->errstr = apr_psprintf(ctx->pool, "Unable to generate random " + "bytes: %pm", &rv); + ret = ERR_RANDOM; + break; + } + + if (ctx->cost == 0) + ctx->cost = BCRYPT_DEFAULT_COST; + rv = apr_bcrypt_encode(pw, ctx->cost, (unsigned char*)salt, 16, + ctx->out, ctx->out_len); + if (rv != APR_SUCCESS) { + ctx->errstr = apr_psprintf(ctx->pool, "Unable to encode with " + "bcrypt: %pm", &rv); + ret = ERR_PWMISMATCH; + break; + } + break; +#endif /* BCRYPT_ALGO_SUPPORTED */ + + default: + ctx->errstr = apr_psprintf(ctx->pool, + "mk_password_hash(): unsupported algorithm %d", + ctx->alg); + ret = ERR_GENERAL; + } + memset(pw, '\0', strlen(pw)); + return ret; +} + + diff --git a/modules/lua/lua_passwd.h b/modules/lua/lua_passwd.h new file mode 100644 index 0000000..8606cc1 --- /dev/null +++ b/modules/lua/lua_passwd.h @@ -0,0 +1,90 @@ +/* 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. + */ + +#ifndef _LUA_PASSWD_H +#define _LUA_PASSWD_H + +#include "apr.h" +#include "apr_lib.h" +#include "apr_strings.h" +#include "apr_errno.h" +#include "apr_file_io.h" +#include "apr_general.h" +#include "apr_version.h" +#if !APR_VERSION_AT_LEAST(2,0,0) +#include "apu_version.h" +#endif + +#define MAX_PASSWD_LEN 256 + +#define ALG_APMD5 0 +#define ALG_APSHA 1 +#define ALG_BCRYPT 2 +#define ALG_CRYPT 3 + +#define BCRYPT_DEFAULT_COST 5 + +#define ERR_FILEPERM 1 +#define ERR_SYNTAX 2 +#define ERR_PWMISMATCH 3 +#define ERR_INTERRUPTED 4 +#define ERR_OVERFLOW 5 +#define ERR_BADUSER 6 +#define ERR_INVALID 7 +#define ERR_RANDOM 8 +#define ERR_GENERAL 9 +#define ERR_ALG_NOT_SUPP 10 + +#if defined(WIN32) || defined(NETWARE) +#define CRYPT_ALGO_SUPPORTED 0 +#define PLAIN_ALGO_SUPPORTED 1 +#else +#define CRYPT_ALGO_SUPPORTED 1 +#define PLAIN_ALGO_SUPPORTED 0 +#endif + +#if APR_VERSION_AT_LEAST(2,0,0) || \ + (APU_MAJOR_VERSION == 1 && APU_MINOR_VERSION >= 5) +#define BCRYPT_ALGO_SUPPORTED 1 +#else +#define BCRYPT_ALGO_SUPPORTED 0 +#endif + +typedef struct passwd_ctx passwd_ctx; + +struct passwd_ctx { + apr_pool_t *pool; + const char *errstr; + char *out; + apr_size_t out_len; + char *passwd; + int alg; + int cost; +}; + + +/* + * The following functions return zero on success; otherwise, one of + * the ERR_* codes is returned and an error message is stored in ctx->errstr. + */ + +/* + * Make a password record from the given information. + */ +int mk_password_hash(passwd_ctx *ctx); + +#endif /* _LUA_PASSWD_H */ + diff --git a/modules/lua/lua_request.c b/modules/lua/lua_request.c new file mode 100644 index 0000000..77a88b4 --- /dev/null +++ b/modules/lua/lua_request.c @@ -0,0 +1,3028 @@ +/** + * 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 "lua_apr.h" +#include "lua_dbd.h" +#include "lua_passwd.h" +#include "scoreboard.h" +#include "util_md5.h" +#include "util_script.h" +#include "util_varbuf.h" +#include "apr_date.h" +#include "apr_pools.h" +#include "apr_thread_mutex.h" +#include "apr_tables.h" +#include "util_cookies.h" + +#define APR_WANT_BYTEFUNC +#include "apr_want.h" + +extern apr_global_mutex_t* lua_ivm_mutex; +extern apr_shm_t *lua_ivm_shm; + +APLOG_USE_MODULE(lua); +#define POST_MAX_VARS 500 + +#ifndef MODLUA_MAX_REG_MATCH +#define MODLUA_MAX_REG_MATCH 25 +#endif + +typedef char *(*req_field_string_f) (request_rec * r); +typedef int (*req_field_int_f) (request_rec * r); +typedef req_table_t *(*req_field_apr_table_f) (request_rec * r); + + +void ap_lua_rstack_dump(lua_State *L, request_rec *r, const char *msg) +{ + int i; + int top = lua_gettop(L); + ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(01484) "Lua Stack Dump: [%s]", msg); + for (i = 1; i <= top; i++) { + int t = lua_type(L, i); + switch (t) { + case LUA_TSTRING:{ + ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03001) + "%d: '%s'", i, lua_tostring(L, i)); + break; + } + case LUA_TUSERDATA:{ + ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03002) + "%d: userdata", i); + break; + } + case LUA_TLIGHTUSERDATA:{ + ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03003) + "%d: lightuserdata", i); + break; + } + case LUA_TNIL:{ + ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03004) + "%d: NIL", i); + break; + } + case LUA_TNONE:{ + ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03005) + "%d: None", i); + break; + } + case LUA_TBOOLEAN:{ + ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03006) + "%d: %s", i, + lua_toboolean(L, i) ? "true" : "false"); + break; + } + case LUA_TNUMBER:{ + ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03007) + "%d: %g", i, lua_tonumber(L, i)); + break; + } + case LUA_TTABLE:{ + ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03008) + "%d: <table>", i); + break; + } + case LUA_TFUNCTION:{ + ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03009) + "%d: <function>", i); + break; + } + default:{ + ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03010) + "%d: unknown: -[%s]-", i, lua_typename(L, i)); + break; + } + } + } +} + +/** + * Verify that the thing at index is a request_rec wrapping + * userdata thingamajig and return it if it is. if it is not + * lua will enter its error handling routine. + */ +static request_rec *ap_lua_check_request_rec(lua_State *L, int index) +{ + request_rec *r; + luaL_checkudata(L, index, "Apache2.Request"); + r = (request_rec *) lua_unboxpointer(L, index); + return r; +} + +/* ------------------ request methods -------------------- */ +/* helper callback for req_parseargs */ +static int req_aprtable2luatable_cb(void *l, const char *key, + const char *value) +{ + int t; + lua_State *L = (lua_State *) l; /* [table<s,t>, table<s,s>] */ + /* rstack_dump(L, RRR, "start of cb"); */ + /* L is [table<s,t>, table<s,s>] */ + /* build complex */ + + lua_getfield(L, -1, key); /* [VALUE, table<s,t>, table<s,s>] */ + /* rstack_dump(L, RRR, "after getfield"); */ + t = lua_type(L, -1); + switch (t) { + case LUA_TNIL: + case LUA_TNONE:{ + lua_pop(L, 1); /* [table<s,t>, table<s,s>] */ + lua_newtable(L); /* [array, table<s,t>, table<s,s>] */ + lua_pushnumber(L, 1); /* [1, array, table<s,t>, table<s,s>] */ + lua_pushstring(L, value); /* [string, 1, array, table<s,t>, table<s,s>] */ + lua_settable(L, -3); /* [array, table<s,t>, table<s,s>] */ + lua_setfield(L, -2, key); /* [table<s,t>, table<s,s>] */ + break; + } + case LUA_TTABLE:{ + /* [array, table<s,t>, table<s,s>] */ + int size = lua_rawlen(L, -1); + lua_pushnumber(L, size + 1); /* [#, array, table<s,t>, table<s,s>] */ + lua_pushstring(L, value); /* [string, #, array, table<s,t>, table<s,s>] */ + lua_settable(L, -3); /* [array, table<s,t>, table<s,s>] */ + lua_setfield(L, -2, key); /* [table<s,t>, table<s,s>] */ + break; + } + } + + /* L is [table<s,t>, table<s,s>] */ + /* build simple */ + lua_getfield(L, -2, key); /* [VALUE, table<s,s>, table<s,t>] */ + if (lua_isnoneornil(L, -1)) { /* only set if not already set */ + lua_pop(L, 1); /* [table<s,s>, table<s,t>]] */ + lua_pushstring(L, value); /* [string, table<s,s>, table<s,t>] */ + lua_setfield(L, -3, key); /* [table<s,s>, table<s,t>] */ + } + else { + lua_pop(L, 1); + } + return 1; +} + +/* helper callback for req_parseargs */ +static int req_aprtable2luatable_cb_len(void *l, const char *key, + const char *value, size_t len) +{ + int t; + lua_State *L = (lua_State *) l; /* [table<s,t>, table<s,s>] */ + /* rstack_dump(L, RRR, "start of cb"); */ + /* L is [table<s,t>, table<s,s>] */ + /* build complex */ + + lua_getfield(L, -1, key); /* [VALUE, table<s,t>, table<s,s>] */ + /* rstack_dump(L, RRR, "after getfield"); */ + t = lua_type(L, -1); + switch (t) { + case LUA_TNIL: + case LUA_TNONE:{ + lua_pop(L, 1); /* [table<s,t>, table<s,s>] */ + lua_newtable(L); /* [array, table<s,t>, table<s,s>] */ + lua_pushnumber(L, 1); /* [1, array, table<s,t>, table<s,s>] */ + lua_pushlstring(L, value, len); /* [string, 1, array, table<s,t>, table<s,s>] */ + lua_settable(L, -3); /* [array, table<s,t>, table<s,s>] */ + lua_setfield(L, -2, key); /* [table<s,t>, table<s,s>] */ + break; + } + + case LUA_TTABLE:{ + /* [array, table<s,t>, table<s,s>] */ + int size = lua_rawlen(L, -1); + lua_pushnumber(L, size + 1); /* [#, array, table<s,t>, table<s,s>] */ + lua_pushlstring(L, value, len); /* [string, #, array, table<s,t>, table<s,s>] */ + lua_settable(L, -3); /* [array, table<s,t>, table<s,s>] */ + lua_setfield(L, -2, key); /* [table<s,t>, table<s,s>] */ + break; + } + } + + /* L is [table<s,t>, table<s,s>] */ + /* build simple */ + lua_getfield(L, -2, key); /* [VALUE, table<s,s>, table<s,t>] */ + if (lua_isnoneornil(L, -1)) { /* only set if not already set */ + lua_pop(L, 1); /* [table<s,s>, table<s,t>]] */ + lua_pushlstring(L, value, len); /* [string, table<s,s>, table<s,t>] */ + lua_setfield(L, -3, key); /* [table<s,s>, table<s,t>] */ + } + else { + lua_pop(L, 1); + } + return 1; +} + + +/* + ======================================================================================================================= + lua_read_body(request_rec *r, const char **rbuf, apr_off_t *size): Reads any additional form data sent in POST/PUT + requests. Used for multipart POST data. + ======================================================================================================================= + */ +static int lua_read_body(request_rec *r, const char **rbuf, apr_off_t *size, + apr_off_t maxsize) +{ + int rc = OK; + + if ((rc = ap_setup_client_block(r, REQUEST_CHUNKED_ERROR))) { + return (rc); + } + if (ap_should_client_block(r)) { + + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + char argsbuffer[HUGE_STRING_LEN]; + apr_off_t rsize, len_read, rpos = 0; + apr_off_t length = r->remaining; + /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/ + + if (maxsize != 0 && length > maxsize) { + return APR_EINCOMPLETE; /* Only room for incomplete data chunk :( */ + } + *rbuf = (const char *) apr_pcalloc(r->pool, (apr_size_t) (length + 1)); + *size = length; + while ((len_read = ap_get_client_block(r, argsbuffer, sizeof(argsbuffer))) > 0) { + if ((rpos + len_read) > length) { + rsize = length - rpos; + } + else { + rsize = len_read; + } + + memcpy((char *) *rbuf + rpos, argsbuffer, (size_t) rsize); + rpos += rsize; + } + } + + return (rc); +} + + +/* + * ======================================================================================================================= + * lua_write_body: Reads any additional form data sent in POST/PUT requests + * and writes to a file. + * ======================================================================================================================= + */ +static apr_status_t lua_write_body(request_rec *r, apr_file_t *file, apr_off_t *size) +{ + apr_status_t rc = OK; + + if ((rc = ap_setup_client_block(r, REQUEST_CHUNKED_ERROR))) + return rc; + if (ap_should_client_block(r)) { + char argsbuffer[HUGE_STRING_LEN]; + apr_off_t rsize, + len_read, + rpos = 0; + apr_off_t length = r->remaining; + + *size = length; + while ((len_read = + ap_get_client_block(r, argsbuffer, + sizeof(argsbuffer))) > 0) { + if ((rpos + len_read) > length) + rsize = (apr_size_t) length - rpos; + else + rsize = len_read; + + rc = apr_file_write_full(file, argsbuffer, (apr_size_t) rsize, + NULL); + if (rc != APR_SUCCESS) + return rc; + rpos += rsize; + } + } + + return rc; +} + +/* r:parseargs() returning a lua table */ +static int req_parseargs(lua_State *L) +{ + apr_table_t *form_table; + request_rec *r = ap_lua_check_request_rec(L, 1); + lua_newtable(L); + lua_newtable(L); /* [table, table] */ + ap_args_to_table(r, &form_table); + apr_table_do(req_aprtable2luatable_cb, L, form_table, NULL); + return 2; /* [table<string, string>, table<string, array<string>>] */ +} + +/* ap_lua_binstrstr: Binary strstr function for uploaded data with NULL bytes */ +static char* ap_lua_binstrstr (const char * haystack, size_t hsize, const char* needle, size_t nsize) +{ + size_t p; + if (haystack == NULL) return NULL; + if (needle == NULL) return NULL; + if (hsize < nsize) return NULL; + for (p = 0; p <= (hsize - nsize); ++p) { + if (memcmp(haystack + p, needle, nsize) == 0) { + return (char*) (haystack + p); + } + } + return NULL; +} + +/* r:parsebody(): Parses regular (url-enocded) or multipart POST data and returns two tables*/ +static int req_parsebody(lua_State *L) +{ + apr_array_header_t *pairs; + apr_off_t len; + int res; + apr_size_t size; + apr_size_t max_post_size; + char *multipart; + const char *contentType; + request_rec *r = ap_lua_check_request_rec(L, 1); + max_post_size = (apr_size_t) luaL_optinteger(L, 2, MAX_STRING_LEN); + multipart = apr_pcalloc(r->pool, 256); + contentType = apr_table_get(r->headers_in, "Content-Type"); + lua_newtable(L); + lua_newtable(L); /* [table, table] */ + if (contentType != NULL && (sscanf(contentType, "multipart/form-data; boundary=%250c", multipart) == 1)) { + char *buffer, *key, *filename; + char *start = 0, *end = 0, *crlf = 0; + const char *data; + int i; + size_t vlen = 0; + size_t len = 0; + if (lua_read_body(r, &data, (apr_off_t*) &size, max_post_size) != OK) { + return 2; + } + len = strlen(multipart); + i = 0; + for + ( + start = strstr((char *) data, multipart); + start != NULL; + start = end + ) { + i++; + if (i == POST_MAX_VARS) break; + crlf = strstr((char *) start, "\r\n\r\n"); + if (!crlf) break; + end = ap_lua_binstrstr(crlf, (size - (crlf - data)), multipart, len); + if (end == NULL) break; + key = (char *) apr_pcalloc(r->pool, 256); + filename = (char *) apr_pcalloc(r->pool, 256); + vlen = end - crlf - 8; + buffer = (char *) apr_pcalloc(r->pool, vlen+1); + memcpy(buffer, crlf + 4, vlen); + sscanf(start + len + 2, + "Content-Disposition: form-data; name=\"%255[^\"]\"; filename=\"%255[^\"]\"", + key, filename); + if (*key) { + req_aprtable2luatable_cb_len(L, key, buffer, vlen); + } + } + } + else { + char *buffer; + res = ap_parse_form_data(r, NULL, &pairs, -1, max_post_size); + if (res == OK) { + while(pairs && !apr_is_empty_array(pairs)) { + ap_form_pair_t *pair = (ap_form_pair_t *) apr_array_pop(pairs); + apr_brigade_length(pair->value, 1, &len); + size = (apr_size_t) len; + buffer = apr_palloc(r->pool, size + 1); + apr_brigade_flatten(pair->value, buffer, &size); + buffer[len] = 0; + req_aprtable2luatable_cb(L, pair->name, buffer); + } + } + } + return 2; /* [table<string, string>, table<string, array<string>>] */ +} + + +/* + * lua_ap_requestbody; r:requestbody([filename]) - Reads or stores the request + * body + */ +static int lua_ap_requestbody(lua_State *L) +{ + const char *filename; + request_rec *r; + apr_off_t maxSize; + + r = ap_lua_check_request_rec(L, 1); + filename = luaL_optstring(L, 2, 0); + maxSize = (apr_off_t)luaL_optinteger(L, 3, 0); + + if (r) { + apr_off_t size; + if (maxSize > 0 && r->remaining > maxSize) { + lua_pushnil(L); + lua_pushliteral(L, "Request body was larger than the permitted size."); + return 2; + } + if (r->method_number != M_POST && r->method_number != M_PUT) + return (0); + if (!filename) { + const char *data; + + if (lua_read_body(r, &data, &size, maxSize) != OK) + return (0); + + lua_pushlstring(L, data, (size_t) size); + lua_pushinteger(L, (lua_Integer) size); + return (2); + } else { + apr_status_t rc; + apr_file_t *file; + + rc = apr_file_open(&file, filename, APR_CREATE | APR_FOPEN_WRITE, + APR_FPROT_OS_DEFAULT, r->pool); + lua_settop(L, 0); + if (rc == APR_SUCCESS) { + rc = lua_write_body(r, file, &size); + apr_file_close(file); + if (rc != OK) { + lua_pushboolean(L, 0); + return 1; + } + lua_pushinteger(L, (lua_Integer) size); + return (1); + } else + lua_pushboolean(L, 0); + return (1); + } + } + + return (0); +} + +/* wrap ap_rputs as r:puts(String) */ +static int req_puts(lua_State *L) +{ + request_rec *r = ap_lua_check_request_rec(L, 1); + + int argc = lua_gettop(L); + int i; + + for (i = 2; i <= argc; i++) { + ap_rputs(luaL_checkstring(L, i), r); + } + return 0; +} + +/* wrap ap_rwrite as r:write(String) */ +static int req_write(lua_State *L) +{ + request_rec *r = ap_lua_check_request_rec(L, 1); + size_t n; + int rv; + const char *buf = luaL_checklstring(L, 2, &n); + + rv = ap_rwrite((void *) buf, n, r); + lua_pushinteger(L, rv); + return 1; +} + +/* r:add_output_filter(name) */ +static int req_add_output_filter(lua_State *L) +{ + request_rec *r = ap_lua_check_request_rec(L, 1); + const char *name = luaL_checkstring(L, 2); + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01485) "adding output filter %s", + name); + ap_add_output_filter(name, L, r, r->connection); + return 0; +} + +/* wrap ap_construct_url as r:construct_url(String) */ +static int req_construct_url(lua_State *L) +{ + request_rec *r = ap_lua_check_request_rec(L, 1); + const char *name = luaL_checkstring(L, 2); + lua_pushstring(L, ap_construct_url(r->pool, name, r)); + return 1; +} + +/* wrap ap_escape_html r:escape_html(String) */ +static int req_escape_html(lua_State *L) +{ + request_rec *r = ap_lua_check_request_rec(L, 1); + const char *s = luaL_checkstring(L, 2); + lua_pushstring(L, ap_escape_html(r->pool, s)); + return 1; +} + +/* wrap optional ssl_var_lookup as r:ssl_var_lookup(String) */ +static int req_ssl_var_lookup(lua_State *L) +{ + request_rec *r = ap_lua_check_request_rec(L, 1); + const char *s = luaL_checkstring(L, 2); + const char *res = ap_lua_ssl_val(r->pool, r->server, r->connection, r, + (char *)s); + lua_pushstring(L, res); + return 1; +} + +/* BEGIN dispatch mathods for request_rec fields */ + +/* not really a field, but we treat it like one */ +static const char *req_document_root(request_rec *r) +{ + return ap_document_root(r); +} + +static const char *req_context_prefix(request_rec *r) +{ + return ap_context_prefix(r); +} + +static const char *req_context_document_root(request_rec *r) +{ + return ap_context_document_root(r); +} + +static char *req_uri_field(request_rec *r) +{ + return r->uri; +} + +static const char *req_method_field(request_rec *r) +{ + return r->method; +} +static const char *req_handler_field(request_rec *r) +{ + return r->handler; +} +static const char *req_proxyreq_field(request_rec *r) +{ + switch (r->proxyreq) { + case PROXYREQ_NONE: return "PROXYREQ_NONE"; + case PROXYREQ_PROXY: return "PROXYREQ_PROXY"; + case PROXYREQ_REVERSE: return "PROXYREQ_REVERSE"; + case PROXYREQ_RESPONSE: return "PROXYREQ_RESPONSE"; + default: return NULL; + } +} +static const char *req_hostname_field(request_rec *r) +{ + return r->hostname; +} + +static const char *req_args_field(request_rec *r) +{ + return r->args; +} + +static const char *req_path_info_field(request_rec *r) +{ + return r->path_info; +} + +static const char *req_canonical_filename_field(request_rec *r) +{ + return r->canonical_filename; +} + +static const char *req_filename_field(request_rec *r) +{ + return r->filename; +} + +static const char *req_user_field(request_rec *r) +{ + return r->user; +} + +static const char *req_unparsed_uri_field(request_rec *r) +{ + return r->unparsed_uri; +} + +static const char *req_ap_auth_type_field(request_rec *r) +{ + return r->ap_auth_type; +} + +static const char *req_content_encoding_field(request_rec *r) +{ + return r->content_encoding; +} + +static const char *req_content_type_field(request_rec *r) +{ + return r->content_type; +} + +static const char *req_range_field(request_rec *r) +{ + return r->range; +} + +static const char *req_protocol_field(request_rec *r) +{ + return r->protocol; +} + +static const char *req_the_request_field(request_rec *r) +{ + return r->the_request; +} + +static const char *req_log_id_field(request_rec *r) +{ + return r->log_id; +} + +static const char *req_useragent_ip_field(request_rec *r) +{ + return r->useragent_ip; +} + +static int req_remaining_field(request_rec *r) +{ + return r->remaining; +} + +static int req_status_field(request_rec *r) +{ + return r->status; +} + +static int req_assbackwards_field(request_rec *r) +{ + return r->assbackwards; +} + +static req_table_t* req_headers_in(request_rec *r) +{ + req_table_t* t = apr_palloc(r->pool, sizeof(req_table_t)); + t->r = r; + t->t = r->headers_in; + t->n = "headers_in"; + return t; +} + +static req_table_t* req_headers_out(request_rec *r) +{ + req_table_t* t = apr_palloc(r->pool, sizeof(req_table_t)); + t->r = r; + t->t = r->headers_out; + t->n = "headers_out"; + return t; +} + +static req_table_t* req_err_headers_out(request_rec *r) +{ + req_table_t* t = apr_palloc(r->pool, sizeof(req_table_t)); + t->r = r; + t->t = r->err_headers_out; + t->n = "err_headers_out"; + return t; +} + +static req_table_t* req_subprocess_env(request_rec *r) +{ + req_table_t* t = apr_palloc(r->pool, sizeof(req_table_t)); + t->r = r; + t->t = r->subprocess_env; + t->n = "subprocess_env"; + return t; +} + +static req_table_t* req_notes(request_rec *r) +{ + req_table_t* t = apr_palloc(r->pool, sizeof(req_table_t)); + t->r = r; + t->t = r->notes; + t->n = "notes"; + return t; +} + +static int req_ssl_is_https_field(request_rec *r) +{ + return ap_lua_ssl_is_https(r->connection); +} + +static int req_ap_get_server_port(request_rec *r) +{ + return (int) ap_get_server_port(r); +} + +static int lua_ap_rflush (lua_State *L) { + + int returnValue; + request_rec *r; + luaL_checktype(L, 1, LUA_TUSERDATA); + r = ap_lua_check_request_rec(L, 1); + returnValue = ap_rflush(r); + lua_pushboolean(L, (returnValue == 0)); + return 1; +} + + +static const char* lua_ap_options(request_rec* r) +{ + int opts; + opts = ap_allow_options(r); + return apr_psprintf(r->pool, "%s %s %s %s %s %s", (opts&OPT_INDEXES) ? "Indexes" : "", (opts&OPT_INCLUDES) ? "Includes" : "", (opts&OPT_SYM_LINKS) ? "FollowSymLinks" : "", (opts&OPT_EXECCGI) ? "ExecCGI" : "", (opts&OPT_MULTI) ? "MultiViews" : "", (opts&OPT_ALL) == OPT_ALL ? "All" : "" ); +} + +static const char* lua_ap_allowoverrides(request_rec* r) +{ + int opts; + opts = ap_allow_overrides(r); + if ( (opts & OR_ALL) == OR_ALL) { + return "All"; + } + else if (opts == OR_NONE) { + return "None"; + } + return apr_psprintf(r->pool, "%s %s %s %s %s", (opts & OR_LIMIT) ? "Limit" : "", (opts & OR_OPTIONS) ? "Options" : "", (opts & OR_FILEINFO) ? "FileInfo" : "", (opts & OR_AUTHCFG) ? "AuthCfg" : "", (opts & OR_INDEXES) ? "Indexes" : "" ); + +} + +static int lua_ap_started(request_rec* r) +{ + return (int)(ap_scoreboard_image->global->restart_time / 1000000); +} + +static const char* lua_ap_basic_auth_pw(request_rec* r) +{ + const char* pw = NULL; + ap_get_basic_auth_pw(r, &pw); + return pw ? pw : ""; +} + +static int lua_ap_limit_req_body(request_rec* r) +{ + return (int) ap_get_limit_req_body(r); +} + +static int lua_ap_is_initial_req(request_rec *r) +{ + return ap_is_initial_req(r); +} + +static int lua_ap_some_auth_required(request_rec *r) +{ + return ap_some_auth_required(r); +} + +static int lua_ap_sendfile(lua_State *L) +{ + + apr_finfo_t file_info; + const char *filename; + request_rec *r; + + luaL_checktype(L, 1, LUA_TUSERDATA); + luaL_checktype(L, 2, LUA_TSTRING); + r = ap_lua_check_request_rec(L, 1); + filename = lua_tostring(L, 2); + apr_stat(&file_info, filename, APR_FINFO_MIN, r->pool); + if (file_info.filetype == APR_NOFILE || file_info.filetype == APR_DIR) { + lua_pushboolean(L, 0); + } + else { + apr_size_t sent; + apr_status_t rc; + apr_file_t *file; + + rc = apr_file_open(&file, filename, APR_READ, APR_OS_DEFAULT, + r->pool); + if (rc == APR_SUCCESS) { + ap_send_fd(file, r, 0, (apr_size_t)file_info.size, &sent); + apr_file_close(file); + lua_pushinteger(L, sent); + } + else { + lua_pushboolean(L, 0); + } + } + + return (1); +} + + +/* + * lua_apr_b64encode; r:encode_base64(string) - encodes a string to Base64 + * format + */ +static int lua_apr_b64encode(lua_State *L) +{ + const char *plain; + char *encoded; + size_t plain_len, encoded_len; + request_rec *r; + + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + plain = lua_tolstring(L, 2, &plain_len); + encoded_len = apr_base64_encode_len(plain_len); + if (encoded_len) { + encoded = apr_palloc(r->pool, encoded_len); + encoded_len = apr_base64_encode(encoded, plain, plain_len); + if (encoded_len > 0 && encoded[encoded_len - 1] == '\0') + encoded_len--; + lua_pushlstring(L, encoded, encoded_len); + return 1; + } + return 0; +} + +/* + * lua_apr_b64decode; r:decode_base64(string) - decodes a Base64 string + */ +static int lua_apr_b64decode(lua_State *L) +{ + const char *encoded; + char *plain; + size_t encoded_len, decoded_len; + request_rec *r; + + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + encoded = lua_tolstring(L, 2, &encoded_len); + decoded_len = apr_base64_decode_len(encoded); + if (decoded_len) { + plain = apr_palloc(r->pool, decoded_len); + decoded_len = apr_base64_decode(plain, encoded); + if (decoded_len > 0 && plain[decoded_len - 1] == '\0') + decoded_len--; + lua_pushlstring(L, plain, decoded_len); + return 1; + } + return 0; +} + +/* + * lua_ap_unescape; r:unescape(string) - Unescapes an URL-encoded string + */ +static int lua_ap_unescape(lua_State *L) +{ + const char *escaped; + char *plain; + size_t x, + y; + request_rec *r; + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + escaped = lua_tolstring(L, 2, &x); + plain = apr_pstrdup(r->pool, escaped); + y = ap_unescape_urlencoded(plain); + if (!y) { + lua_pushstring(L, plain); + return 1; + } + return 0; +} + +/* + * lua_ap_escape; r:escape(string) - URL-escapes a string + */ +static int lua_ap_escape(lua_State *L) +{ + const char *plain; + char *escaped; + size_t x; + request_rec *r; + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + plain = lua_tolstring(L, 2, &x); + escaped = ap_escape_urlencoded(r->pool, plain); + lua_pushstring(L, escaped); + return 1; +} + +/* + * lua_apr_md5; r:md5(string) - Calculates an MD5 digest of a string + */ +static int lua_apr_md5(lua_State *L) +{ + const char *buffer; + char *result; + size_t len; + request_rec *r; + + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + buffer = lua_tolstring(L, 2, &len); + result = ap_md5_binary(r->pool, (const unsigned char *)buffer, len); + lua_pushstring(L, result); + return 1; +} + +/* + * lua_apr_sha1; r:sha1(string) - Calculates the SHA1 digest of a string + */ +static int lua_apr_sha1(lua_State *L) +{ + unsigned char digest[APR_SHA1_DIGESTSIZE]; + apr_sha1_ctx_t sha1; + const char *buffer; + char *result; + size_t len; + request_rec *r; + + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + result = apr_pcalloc(r->pool, sizeof(digest) * 2 + 1); + buffer = lua_tolstring(L, 2, &len); + apr_sha1_init(&sha1); + apr_sha1_update(&sha1, buffer, len); + apr_sha1_final(digest, &sha1); + + ap_bin2hex(digest, sizeof(digest), result); + lua_pushstring(L, result); + return 1; +} + +/* + * lua_apr_htpassword; r:htpassword(string [, algorithm [, cost]]) - Creates + * a htpassword hash from a string + */ +static int lua_apr_htpassword(lua_State *L) +{ + passwd_ctx ctx = { 0 }; + request_rec *r; + + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + ctx.passwd = apr_pstrdup(r->pool, lua_tostring(L, 2)); + ctx.alg = luaL_optinteger(L, 3, ALG_APMD5); + ctx.cost = luaL_optinteger(L, 4, 0); + ctx.pool = r->pool; + ctx.out = apr_pcalloc(r->pool, MAX_PASSWD_LEN); + ctx.out_len = MAX_PASSWD_LEN; + if (mk_password_hash(&ctx)) { + lua_pushboolean(L, 0); + lua_pushstring(L, ctx.errstr); + return 2; + } else { + lua_pushstring(L, ctx.out); + } + return 1; +} + +/* + * lua_apr_touch; r:touch(string [, time]) - Sets mtime of a file + */ +static int lua_apr_touch(lua_State *L) +{ + request_rec *r; + const char *path; + apr_status_t status; + apr_time_t mtime; + + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + path = lua_tostring(L, 2); + mtime = (apr_time_t)luaL_optnumber(L, 3, (lua_Number)apr_time_now()); + status = apr_file_mtime_set(path, mtime, r->pool); + lua_pushboolean(L, (status == 0)); + return 1; +} + +/* + * lua_apr_mkdir; r:mkdir(string [, permissions]) - Creates a directory + */ +static int lua_apr_mkdir(lua_State *L) +{ + request_rec *r; + const char *path; + apr_status_t status; + apr_fileperms_t perms; + + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + path = lua_tostring(L, 2); + perms = luaL_optinteger(L, 3, APR_OS_DEFAULT); + status = apr_dir_make(path, perms, r->pool); + lua_pushboolean(L, (status == 0)); + return 1; +} + +/* + * lua_apr_mkrdir; r:mkrdir(string [, permissions]) - Creates directories + * recursive + */ +static int lua_apr_mkrdir(lua_State *L) +{ + request_rec *r; + const char *path; + apr_status_t status; + apr_fileperms_t perms; + + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + path = lua_tostring(L, 2); + perms = luaL_optinteger(L, 3, APR_OS_DEFAULT); + status = apr_dir_make_recursive(path, perms, r->pool); + lua_pushboolean(L, (status == 0)); + return 1; +} + +/* + * lua_apr_rmdir; r:rmdir(string) - Removes a directory + */ +static int lua_apr_rmdir(lua_State *L) +{ + request_rec *r; + const char *path; + apr_status_t status; + + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + path = lua_tostring(L, 2); + status = apr_dir_remove(path, r->pool); + lua_pushboolean(L, (status == 0)); + return 1; +} + +/* + * lua_apr_date_parse_rfc; r.date_parse_rfc(string) - Parses a DateTime string + */ +static int lua_apr_date_parse_rfc(lua_State *L) +{ + const char *input; + apr_time_t result; + + luaL_checktype(L, 1, LUA_TSTRING); + input = lua_tostring(L, 1); + result = apr_date_parse_rfc(input); + if (result == 0) + return 0; + lua_pushnumber(L, (lua_Number)(result / APR_USEC_PER_SEC)); + return 1; +} + +/* + * lua_ap_mpm_query; r:mpm_query(info) - Queries for MPM info + */ +static int lua_ap_mpm_query(lua_State *L) +{ + int x, + y; + + x = lua_tointeger(L, 1); + ap_mpm_query(x, &y); + lua_pushinteger(L, y); + return 1; +} + +/* + * lua_ap_expr; r:expr(string) - Evaluates an expr statement. + */ +static int lua_ap_expr(lua_State *L) +{ + request_rec *r; + int x = 0; + const char *expr, + *err; + ap_expr_info_t res; + + luaL_checktype(L, 1, LUA_TUSERDATA); + luaL_checktype(L, 2, LUA_TSTRING); + r = ap_lua_check_request_rec(L, 1); + expr = lua_tostring(L, 2); + + + res.filename = NULL; + res.flags = 0; + res.line_number = 0; + res.module_index = APLOG_MODULE_INDEX; + + err = ap_expr_parse(r->pool, r->pool, &res, expr, NULL); + if (!err) { + x = ap_expr_exec(r, &res, &err); + lua_pushboolean(L, x); + if (x < 0) { + lua_pushstring(L, err); + return 2; + } + return 1; + } else { + lua_pushboolean(L, 0); + lua_pushstring(L, err); + return 2; + } + lua_pushboolean(L, 0); + return 1; +} + + +/* + * lua_ap_regex; r:regex(string, pattern [, flags]) + * - Evaluates a regex and returns captures if matched + */ +static int lua_ap_regex(lua_State *L) +{ + request_rec *r; + int i, + rv, + flags; + const char *pattern, + *source; + char *err; + ap_regex_t regex; + ap_regmatch_t matches[MODLUA_MAX_REG_MATCH+1]; + + luaL_checktype(L, 1, LUA_TUSERDATA); + luaL_checktype(L, 2, LUA_TSTRING); + luaL_checktype(L, 3, LUA_TSTRING); + r = ap_lua_check_request_rec(L, 1); + source = lua_tostring(L, 2); + pattern = lua_tostring(L, 3); + flags = luaL_optinteger(L, 4, 0); + + rv = ap_regcomp(®ex, pattern, flags); + if (rv) { + lua_pushboolean(L, 0); + err = apr_palloc(r->pool, 256); + ap_regerror(rv, ®ex, err, 256); + lua_pushstring(L, err); + return 2; + } + + if (regex.re_nsub > MODLUA_MAX_REG_MATCH) { + lua_pushboolean(L, 0); + err = apr_palloc(r->pool, 64); + apr_snprintf(err, 64, + "regcomp found %d matches; only %d allowed.", + regex.re_nsub, MODLUA_MAX_REG_MATCH); + lua_pushstring(L, err); + return 2; + } + + rv = ap_regexec(®ex, source, MODLUA_MAX_REG_MATCH, matches, 0); + if (rv == AP_REG_NOMATCH) { + lua_pushboolean(L, 0); + return 1; + } + + lua_newtable(L); + for (i = 0; i <= regex.re_nsub; i++) { + lua_pushinteger(L, i); + if (matches[i].rm_so >= 0 && matches[i].rm_eo >= 0) + lua_pushstring(L, + apr_pstrndup(r->pool, source + matches[i].rm_so, + matches[i].rm_eo - matches[i].rm_so)); + else + lua_pushnil(L); + lua_settable(L, -3); + + } + return 1; +} + + + + +/* + * lua_ap_scoreboard_process; r:scoreboard_process(a) - returns scoreboard info + */ +static int lua_ap_scoreboard_process(lua_State *L) +{ + int i; + process_score *ps_record; + + luaL_checktype(L, 1, LUA_TUSERDATA); + luaL_checktype(L, 2, LUA_TNUMBER); + i = lua_tointeger(L, 2); + ps_record = ap_get_scoreboard_process(i); + if (ps_record) { + lua_newtable(L); + + lua_pushstring(L, "connections"); + lua_pushnumber(L, ps_record->connections); + lua_settable(L, -3); + + lua_pushstring(L, "keepalive"); + lua_pushnumber(L, ps_record->keep_alive); + lua_settable(L, -3); + + lua_pushstring(L, "lingering_close"); + lua_pushnumber(L, ps_record->lingering_close); + lua_settable(L, -3); + + lua_pushstring(L, "pid"); + lua_pushnumber(L, ps_record->pid); + lua_settable(L, -3); + + lua_pushstring(L, "suspended"); + lua_pushnumber(L, ps_record->suspended); + lua_settable(L, -3); + + lua_pushstring(L, "write_completion"); + lua_pushnumber(L, ps_record->write_completion); + lua_settable(L, -3); + + lua_pushstring(L, "not_accepting"); + lua_pushnumber(L, ps_record->not_accepting); + lua_settable(L, -3); + + lua_pushstring(L, "quiescing"); + lua_pushnumber(L, ps_record->quiescing); + lua_settable(L, -3); + + return 1; + } + return 0; +} + +/* + * lua_ap_scoreboard_worker; r:scoreboard_worker(proc, thread) - Returns thread + * info + */ +static int lua_ap_scoreboard_worker(lua_State *L) +{ + int i, j; + worker_score *ws_record = NULL; + request_rec *r = NULL; + + luaL_checktype(L, 1, LUA_TUSERDATA); + luaL_checktype(L, 2, LUA_TNUMBER); + luaL_checktype(L, 3, LUA_TNUMBER); + + r = ap_lua_check_request_rec(L, 1); + if (!r) return 0; + + i = lua_tointeger(L, 2); + j = lua_tointeger(L, 3); + ws_record = apr_palloc(r->pool, sizeof *ws_record); + + ap_copy_scoreboard_worker(ws_record, i, j); + if (ws_record) { + lua_newtable(L); + + lua_pushstring(L, "access_count"); + lua_pushnumber(L, ws_record->access_count); + lua_settable(L, -3); + + lua_pushstring(L, "bytes_served"); + lua_pushnumber(L, (lua_Number) ws_record->bytes_served); + lua_settable(L, -3); + + lua_pushstring(L, "client"); + lua_pushstring(L, ws_record->client); + lua_settable(L, -3); + + lua_pushstring(L, "client64"); + lua_pushstring(L, ws_record->client64); + lua_settable(L, -3); + + lua_pushstring(L, "conn_bytes"); + lua_pushnumber(L, (lua_Number) ws_record->conn_bytes); + lua_settable(L, -3); + + lua_pushstring(L, "conn_count"); + lua_pushnumber(L, ws_record->conn_count); + lua_settable(L, -3); + + lua_pushstring(L, "generation"); + lua_pushnumber(L, ws_record->generation); + lua_settable(L, -3); + + lua_pushstring(L, "last_used"); + lua_pushnumber(L, (lua_Number) ws_record->last_used); + lua_settable(L, -3); + + lua_pushstring(L, "pid"); + lua_pushnumber(L, ws_record->pid); + lua_settable(L, -3); + + lua_pushstring(L, "request"); + lua_pushstring(L, ws_record->request); + lua_settable(L, -3); + + lua_pushstring(L, "start_time"); + lua_pushnumber(L, (lua_Number) ws_record->start_time); + lua_settable(L, -3); + + lua_pushstring(L, "status"); + lua_pushnumber(L, ws_record->status); + lua_settable(L, -3); + + lua_pushstring(L, "stop_time"); + lua_pushnumber(L, (lua_Number) ws_record->stop_time); + lua_settable(L, -3); + + lua_pushstring(L, "tid"); + + lua_pushinteger(L, (lua_Integer) ws_record->tid); + lua_settable(L, -3); + + lua_pushstring(L, "vhost"); + lua_pushstring(L, ws_record->vhost); + lua_settable(L, -3); +#ifdef HAVE_TIMES + lua_pushstring(L, "stimes"); + lua_pushnumber(L, ws_record->times.tms_stime); + lua_settable(L, -3); + + lua_pushstring(L, "utimes"); + lua_pushnumber(L, ws_record->times.tms_utime); + lua_settable(L, -3); +#endif + return 1; + } + return 0; +} + +/* + * lua_ap_clock; r:clock() - Returns timestamp with microsecond precision + */ +static int lua_ap_clock(lua_State *L) +{ + apr_time_t now; + now = apr_time_now(); + lua_pushnumber(L, (lua_Number) now); + return 1; +} + +/* + * lua_ap_add_input_filter; r:add_input_filter(name) - Adds an input filter to + * the chain + */ +static int lua_ap_add_input_filter(lua_State *L) +{ + request_rec *r; + const char *filterName; + ap_filter_rec_t *filter; + + luaL_checktype(L, 1, LUA_TUSERDATA); + luaL_checktype(L, 2, LUA_TSTRING); + r = ap_lua_check_request_rec(L, 1); + filterName = lua_tostring(L, 2); + filter = ap_get_input_filter_handle(filterName); + if (filter) { + ap_add_input_filter_handle(filter, NULL, r, r->connection); + lua_pushboolean(L, 1); + } else + lua_pushboolean(L, 0); + return 1; +} + + +/* + * lua_ap_module_info; r:module_info(mod_name) - Returns information about a + * loaded module + */ +static int lua_ap_module_info(lua_State *L) +{ + const char *moduleName; + module *mod; + + luaL_checktype(L, 1, LUA_TSTRING); + moduleName = lua_tostring(L, 1); + mod = ap_find_linked_module(moduleName); + if (mod && mod->cmds) { + const command_rec *cmd; + lua_newtable(L); + lua_pushstring(L, "commands"); + lua_newtable(L); + for (cmd = mod->cmds; cmd->name; ++cmd) { + lua_pushstring(L, cmd->name); + lua_pushstring(L, cmd->errmsg); + lua_settable(L, -3); + } + lua_settable(L, -3); + return 1; + } + return 0; +} + +/* + * lua_ap_runtime_dir_relative: r:runtime_dir_relative(file): Returns the + * filename as relative to the runtime dir + */ +static int lua_ap_runtime_dir_relative(lua_State *L) +{ + request_rec *r; + const char *file; + + luaL_checktype(L, 1, LUA_TUSERDATA); + r = ap_lua_check_request_rec(L, 1); + file = luaL_optstring(L, 2, "."); + lua_pushstring(L, ap_runtime_dir_relative(r->pool, file)); + return 1; +} + +/* + * lua_ap_set_document_root; r:set_document_root(path) - sets the current doc + * root for the request + */ +static int lua_ap_set_document_root(lua_State *L) +{ + request_rec *r; + const char *root; + + luaL_checktype(L, 1, LUA_TUSERDATA); + luaL_checktype(L, 2, LUA_TSTRING); + r = ap_lua_check_request_rec(L, 1); + root = lua_tostring(L, 2); + ap_set_document_root(r, root); + return 0; +} + +/* + * lua_ap_getdir; r:get_direntries(directory) - Gets all entries of a + * directory and returns the directory info as a table + */ +static int lua_ap_getdir(lua_State *L) +{ + request_rec *r; + apr_dir_t *thedir; + apr_finfo_t file_info; + apr_status_t status; + const char *directory; + + luaL_checktype(L, 1, LUA_TUSERDATA); + luaL_checktype(L, 2, LUA_TSTRING); + r = ap_lua_check_request_rec(L, 1); + directory = lua_tostring(L, 2); + if (apr_dir_open(&thedir, directory, r->pool) == APR_SUCCESS) { + int i = 0; + lua_newtable(L); + do { + status = apr_dir_read(&file_info, APR_FINFO_NAME, thedir); + if (APR_STATUS_IS_INCOMPLETE(status)) { + continue; /* ignore un-stat()able files */ + } + else if (status != APR_SUCCESS) { + break; + } + lua_pushinteger(L, ++i); + lua_pushstring(L, file_info.name); + lua_settable(L, -3); + + } while (1); + apr_dir_close(thedir); + return 1; + } + else { + return 0; + } +} + +/* + * lua_ap_stat; r:stat(filename [, wanted]) - Runs stat on a file and + * returns the file info as a table + */ +static int lua_ap_stat(lua_State *L) +{ + request_rec *r; + const char *filename; + apr_finfo_t file_info; + apr_int32_t wanted; + + luaL_checktype(L, 1, LUA_TUSERDATA); + luaL_checktype(L, 2, LUA_TSTRING); + r = ap_lua_check_request_rec(L, 1); + filename = lua_tostring(L, 2); + wanted = luaL_optinteger(L, 3, APR_FINFO_MIN); + if (apr_stat(&file_info, filename, wanted, r->pool) == OK) { + lua_newtable(L); + if (wanted & APR_FINFO_MTIME) { + lua_pushstring(L, "mtime"); + lua_pushnumber(L, (lua_Number) file_info.mtime); + lua_settable(L, -3); + } + if (wanted & APR_FINFO_ATIME) { + lua_pushstring(L, "atime"); + lua_pushnumber(L, (lua_Number) file_info.atime); + lua_settable(L, -3); + } + if (wanted & APR_FINFO_CTIME) { + lua_pushstring(L, "ctime"); + lua_pushnumber(L, (lua_Number) file_info.ctime); + lua_settable(L, -3); + } + if (wanted & APR_FINFO_SIZE) { + lua_pushstring(L, "size"); + lua_pushnumber(L, (lua_Number) file_info.size); + lua_settable(L, -3); + } + if (wanted & APR_FINFO_TYPE) { + lua_pushstring(L, "filetype"); + lua_pushinteger(L, file_info.filetype); + lua_settable(L, -3); + } + if (wanted & APR_FINFO_PROT) { + lua_pushstring(L, "protection"); + lua_pushinteger(L, file_info.protection); + lua_settable(L, -3); + } + return 1; + } + else { + return 0; + } +} + +/* + * lua_ap_loaded_modules; r:loaded_modules() - Returns a list of loaded modules + */ +static int lua_ap_loaded_modules(lua_State *L) +{ + int i; + lua_newtable(L); + for (i = 0; ap_loaded_modules[i] && ap_loaded_modules[i]->name; i++) { + lua_pushinteger(L, i + 1); + lua_pushstring(L, ap_loaded_modules[i]->name); + lua_settable(L, -3); + } + return 1; +} + +/* + * lua_ap_server_info; r:server_info() - Returns server info, such as the + * executable filename, server root, mpm etc + */ +static int lua_ap_server_info(lua_State *L) +{ + lua_newtable(L); + + lua_pushstring(L, "server_executable"); + lua_pushstring(L, ap_server_argv0); + lua_settable(L, -3); + + lua_pushstring(L, "server_root"); + lua_pushstring(L, ap_server_root); + lua_settable(L, -3); + + lua_pushstring(L, "scoreboard_fname"); + lua_pushstring(L, ap_scoreboard_fname); + lua_settable(L, -3); + + lua_pushstring(L, "server_mpm"); + lua_pushstring(L, ap_show_mpm()); + lua_settable(L, -3); + + return 1; +} + + +/* + * === Auto-scraped functions === + */ + + +/** + * ap_set_context_info: Set context_prefix and context_document_root. + * @param r The request + * @param prefix the URI prefix, without trailing slash + * @param document_root the corresponding directory on disk, without trailing + * slash + * @note If one of prefix of document_root is NULL, the corrsponding + * property will not be changed. + */ +static int lua_ap_set_context_info(lua_State *L) +{ + request_rec *r; + const char *prefix; + const char *document_root; + luaL_checktype(L, 1, LUA_TUSERDATA); + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + prefix = lua_tostring(L, 2); + luaL_checktype(L, 3, LUA_TSTRING); + document_root = lua_tostring(L, 3); + ap_set_context_info(r, prefix, document_root); + return 0; +} + + +/** + * ap_os_escape_path (apr_pool_t *p, const char *path, int partial) + * convert an OS path to a URL in an OS dependant way. + * @param p The pool to allocate from + * @param path The path to convert + * @param partial if set, assume that the path will be appended to something + * with a '/' in it (and thus does not prefix "./") + * @return The converted URL + */ +static int lua_ap_os_escape_path(lua_State *L) +{ + char *returnValue; + request_rec *r; + const char *path; + int partial = 0; + luaL_checktype(L, 1, LUA_TUSERDATA); + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + path = lua_tostring(L, 2); + if (lua_isboolean(L, 3)) + partial = lua_toboolean(L, 3); + returnValue = ap_os_escape_path(r->pool, path, partial); + lua_pushstring(L, returnValue); + return 1; +} + + +/** + * ap_escape_logitem (apr_pool_t *p, const char *str) + * Escape a string for logging + * @param p The pool to allocate from + * @param str The string to escape + * @return The escaped string + */ +static int lua_ap_escape_logitem(lua_State *L) +{ + char *returnValue; + request_rec *r; + const char *str; + luaL_checktype(L, 1, LUA_TUSERDATA); + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + str = lua_tostring(L, 2); + returnValue = ap_escape_logitem(r->pool, str); + lua_pushstring(L, returnValue); + return 1; +} + +/** + * ap_strcmp_match (const char *str, const char *expected) + * Determine if a string matches a pattern containing the wildcards '?' or '*' + * @param str The string to check + * @param expected The pattern to match against + * @param ignoreCase Whether to ignore case when matching + * @return 1 if the two strings match, 0 otherwise + */ +static int lua_ap_strcmp_match(lua_State *L) +{ + int returnValue; + const char *str; + const char *expected; + int ignoreCase = 0; + luaL_checktype(L, 1, LUA_TSTRING); + str = lua_tostring(L, 1); + luaL_checktype(L, 2, LUA_TSTRING); + expected = lua_tostring(L, 2); + if (lua_isboolean(L, 3)) + ignoreCase = lua_toboolean(L, 3); + if (!ignoreCase) + returnValue = ap_strcmp_match(str, expected); + else + returnValue = ap_strcasecmp_match(str, expected); + lua_pushboolean(L, (!returnValue)); + return 1; +} + + +/** + * ap_set_keepalive (request_rec *r) + * Set the keepalive status for this request + * @param r The current request + * @return 1 if keepalive can be set, 0 otherwise + */ +static int lua_ap_set_keepalive(lua_State *L) +{ + int returnValue; + request_rec *r; + luaL_checktype(L, 1, LUA_TUSERDATA); + r = ap_lua_check_request_rec(L, 1); + returnValue = ap_set_keepalive(r); + lua_pushboolean(L, returnValue); + return 1; +} + +/** + * ap_make_etag (request_rec *r, int force_weak) + * Construct an entity tag from the resource information. If it's a real + * file, build in some of the file characteristics. + * @param r The current request + * @param force_weak Force the entity tag to be weak - it could be modified + * again in as short an interval. + * @return The entity tag + */ +static int lua_ap_make_etag(lua_State *L) +{ + char *returnValue; + request_rec *r; + int force_weak; + luaL_checktype(L, 1, LUA_TUSERDATA); + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TBOOLEAN); + force_weak = (int)luaL_optinteger(L, 2, 0); + returnValue = ap_make_etag(r, force_weak); + lua_pushstring(L, returnValue); + return 1; +} + + + +/** + * ap_send_interim_response (request_rec *r, int send_headers) + * Send an interim (HTTP 1xx) response immediately. + * @param r The request + * @param send_headers Whether to send&clear headers in r->headers_out + */ +static int lua_ap_send_interim_response(lua_State *L) +{ + request_rec *r; + int send_headers = 0; + luaL_checktype(L, 1, LUA_TUSERDATA); + r = ap_lua_check_request_rec(L, 1); + if (lua_isboolean(L, 2)) + send_headers = lua_toboolean(L, 2); + ap_send_interim_response(r, send_headers); + return 0; +} + + +/** + * ap_custom_response (request_rec *r, int status, const char *string) + * Install a custom response handler for a given status + * @param r The current request + * @param status The status for which the custom response should be used + * @param string The custom response. This can be a static string, a file + * or a URL + */ +static int lua_ap_custom_response(lua_State *L) +{ + request_rec *r; + int status; + const char *string; + luaL_checktype(L, 1, LUA_TUSERDATA); + r = ap_lua_check_request_rec(L, 1); + luaL_checktype(L, 2, LUA_TNUMBER); + status = lua_tointeger(L, 2); + luaL_checktype(L, 3, LUA_TSTRING); + string = lua_tostring(L, 3); + ap_custom_response(r, status, string); + return 0; +} + + +/** + * ap_exists_config_define (const char *name) + * Check for a definition from the server command line + * @param name The define to check for + * @return 1 if defined, 0 otherwise + */ +static int lua_ap_exists_config_define(lua_State *L) +{ + int returnValue; + const char *name; + luaL_checktype(L, 1, LUA_TSTRING); + name = lua_tostring(L, 1); + returnValue = ap_exists_config_define(name); + lua_pushboolean(L, returnValue); + return 1; +} + +static int lua_ap_get_server_name_for_url(lua_State *L) +{ + const char *servername; + request_rec *r; + luaL_checktype(L, 1, LUA_TUSERDATA); + r = ap_lua_check_request_rec(L, 1); + servername = ap_get_server_name_for_url(r); + lua_pushstring(L, servername); + return 1; +} + +/* ap_state_query (int query_code) item starts a new field */ +static int lua_ap_state_query(lua_State *L) +{ + + int returnValue; + int query_code; + luaL_checktype(L, 1, LUA_TNUMBER); + query_code = lua_tointeger(L, 1); + returnValue = ap_state_query(query_code); + lua_pushinteger(L, returnValue); + return 1; +} + +/* + * lua_ap_usleep; r:usleep(microseconds) + * - Sleep for the specified number of microseconds. + */ +static int lua_ap_usleep(lua_State *L) +{ + apr_interval_time_t msec; + luaL_checktype(L, 1, LUA_TNUMBER); + msec = (apr_interval_time_t)lua_tonumber(L, 1); + apr_sleep(msec); + return 0; +} + +/* END dispatch methods for request_rec fields */ + +static int req_dispatch(lua_State *L) +{ + apr_hash_t *dispatch; + req_fun_t *rft; + request_rec *r = ap_lua_check_request_rec(L, 1); + const char *name = luaL_checkstring(L, 2); + lua_pop(L, 2); + + lua_getfield(L, LUA_REGISTRYINDEX, "Apache2.Request.dispatch"); + dispatch = lua_touserdata(L, 1); + lua_pop(L, 1); + + rft = apr_hash_get(dispatch, name, APR_HASH_KEY_STRING); + if (rft) { + switch (rft->type) { + case APL_REQ_FUNTYPE_TABLE:{ + req_table_t *rs; + req_field_apr_table_f func = (req_field_apr_table_f)rft->fun; + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01486) + "request_rec->dispatching %s -> apr table", + name); + rs = (*func)(r); + ap_lua_push_apr_table(L, rs); + return 1; + } + + case APL_REQ_FUNTYPE_LUACFUN:{ + lua_CFunction func = (lua_CFunction)rft->fun; + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01487) + "request_rec->dispatching %s -> lua_CFunction", + name); + lua_pushcfunction(L, func); + return 1; + } + case APL_REQ_FUNTYPE_STRING:{ + req_field_string_f func = (req_field_string_f)rft->fun; + char *rs; + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01488) + "request_rec->dispatching %s -> string", name); + rs = (*func) (r); + lua_pushstring(L, rs); + return 1; + } + case APL_REQ_FUNTYPE_INT:{ + req_field_int_f func = (req_field_int_f)rft->fun; + int rs; + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01489) + "request_rec->dispatching %s -> int", name); + rs = (*func) (r); + lua_pushinteger(L, rs); + return 1; + } + case APL_REQ_FUNTYPE_BOOLEAN:{ + req_field_int_f func = (req_field_int_f)rft->fun; + int rs; + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01490) + "request_rec->dispatching %s -> boolean", name); + rs = (*func) (r); + lua_pushboolean(L, rs); + return 1; + } + } + } + + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01491) "nothing for %s", name); + return 0; +} + +/* helper function for the logging functions below */ +static int req_log_at(lua_State *L, int level) +{ + const char *msg; + request_rec *r = ap_lua_check_request_rec(L, 1); + lua_Debug dbg; + + lua_getstack(L, 1, &dbg); + lua_getinfo(L, "Sl", &dbg); + + msg = luaL_checkstring(L, 2); + /* Intentional no APLOGNO */ + ap_log_rerror(dbg.source, dbg.currentline, APLOG_MODULE_INDEX, level, 0, + r, "%s", msg); + return 0; +} + +/* r:debug(String) and friends which use apache logging */ +static int req_emerg(lua_State *L) +{ + return req_log_at(L, APLOG_EMERG); +} +static int req_alert(lua_State *L) +{ + return req_log_at(L, APLOG_ALERT); +} +static int req_crit(lua_State *L) +{ + return req_log_at(L, APLOG_CRIT); +} +static int req_err(lua_State *L) +{ + return req_log_at(L, APLOG_ERR); +} +static int req_warn(lua_State *L) +{ + return req_log_at(L, APLOG_WARNING); +} +static int req_notice(lua_State *L) +{ + return req_log_at(L, APLOG_NOTICE); +} +static int req_info(lua_State *L) +{ + return req_log_at(L, APLOG_INFO); +} +static int req_debug(lua_State *L) +{ + return req_log_at(L, APLOG_DEBUG); +} + +static int lua_ivm_get(lua_State *L) +{ + const char *key, *raw_key; + apr_pool_t *pool; + lua_ivm_object *object = NULL; + request_rec *r = ap_lua_check_request_rec(L, 1); + key = luaL_checkstring(L, 2); + raw_key = apr_pstrcat(r->pool, "lua_ivm_", key, NULL); + apr_global_mutex_lock(lua_ivm_mutex); + pool = *((apr_pool_t**) apr_shm_baseaddr_get(lua_ivm_shm)); + apr_pool_userdata_get((void **)&object, raw_key, pool); + if (object) { + if (object->type == LUA_TBOOLEAN) lua_pushboolean(L, (int) object->number); + else if (object->type == LUA_TNUMBER) lua_pushnumber(L, object->number); + else if (object->type == LUA_TSTRING) lua_pushlstring(L, object->vb.buf, object->size); + apr_global_mutex_unlock(lua_ivm_mutex); + return 1; + } + else { + apr_global_mutex_unlock(lua_ivm_mutex); + return 0; + } +} + + +static int lua_ivm_set(lua_State *L) +{ + const char *key, *raw_key; + const char *value = NULL; + apr_pool_t *pool; + size_t str_len; + lua_ivm_object *object = NULL; + request_rec *r = ap_lua_check_request_rec(L, 1); + key = luaL_checkstring(L, 2); + luaL_checkany(L, 3); + raw_key = apr_pstrcat(r->pool, "lua_ivm_", key, NULL); + + apr_global_mutex_lock(lua_ivm_mutex); + pool = *((apr_pool_t**) apr_shm_baseaddr_get(lua_ivm_shm)); + apr_pool_userdata_get((void **)&object, raw_key, pool); + if (!object) { + object = apr_pcalloc(pool, sizeof(lua_ivm_object)); + ap_varbuf_init(pool, &object->vb, 2); + object->size = 1; + object->vb_size = 1; + } + object->type = lua_type(L, 3); + if (object->type == LUA_TNUMBER) object->number = lua_tonumber(L, 3); + else if (object->type == LUA_TBOOLEAN) object->number = lua_tonumber(L, 3); + else if (object->type == LUA_TSTRING) { + value = lua_tolstring(L, 3, &str_len); + str_len++; /* add trailing \0 */ + if ( str_len > object->vb_size) { + ap_varbuf_grow(&object->vb, str_len); + object->vb_size = str_len; + } + object->size = str_len-1; + memset(object->vb.buf, 0, str_len); + memcpy(object->vb.buf, value, str_len-1); + } + apr_pool_userdata_set(object, raw_key, NULL, pool); + apr_global_mutex_unlock(lua_ivm_mutex); + return 0; +} + +static int lua_get_cookie(lua_State *L) +{ + const char *key, *cookie; + request_rec *r = ap_lua_check_request_rec(L, 1); + key = luaL_checkstring(L, 2); + cookie = NULL; + ap_cookie_read(r, key, &cookie, 0); + if (cookie != NULL) { + lua_pushstring(L, cookie); + return 1; + } + return 0; +} + +static int lua_set_cookie(lua_State *L) +{ + const char *key, *value, *out, *path = "", *domain = ""; + const char *strexpires = "", *strdomain = "", *strpath = ""; + int secure = 0, expires = 0, httponly = 0; + char cdate[APR_RFC822_DATE_LEN+1]; + apr_status_t rv; + request_rec *r = ap_lua_check_request_rec(L, 1); + + /* New >= 2.4.8 method: */ + if (lua_istable(L, 2)) { + + /* key */ + lua_pushstring(L, "key"); + lua_gettable(L, -2); + key = luaL_checkstring(L, -1); + lua_pop(L, 1); + + /* value */ + lua_pushstring(L, "value"); + lua_gettable(L, -2); + value = luaL_checkstring(L, -1); + lua_pop(L, 1); + + /* expiry */ + lua_pushstring(L, "expires"); + lua_gettable(L, -2); + expires = (int)luaL_optinteger(L, -1, 0); + lua_pop(L, 1); + + /* secure */ + lua_pushstring(L, "secure"); + lua_gettable(L, -2); + if (lua_isboolean(L, -1)) { + secure = lua_toboolean(L, -1); + } + lua_pop(L, 1); + + /* httponly */ + lua_pushstring(L, "httponly"); + lua_gettable(L, -2); + if (lua_isboolean(L, -1)) { + httponly = lua_toboolean(L, -1); + } + lua_pop(L, 1); + + /* path */ + lua_pushstring(L, "path"); + lua_gettable(L, -2); + path = luaL_optstring(L, -1, "/"); + lua_pop(L, 1); + + /* domain */ + lua_pushstring(L, "domain"); + lua_gettable(L, -2); + domain = luaL_optstring(L, -1, ""); + lua_pop(L, 1); + } + /* Old <= 2.4.7 method: */ + else { + key = luaL_checkstring(L, 2); + value = luaL_checkstring(L, 3); + secure = 0; + if (lua_isboolean(L, 4)) { + secure = lua_toboolean(L, 4); + } + expires = luaL_optinteger(L, 5, 0); + } + + /* Calculate expiry if set */ + if (expires > 0) { + rv = apr_rfc822_date(cdate, apr_time_from_sec(expires)); + if (rv == APR_SUCCESS) { + strexpires = apr_psprintf(r->pool, "Expires=%s;", cdate); + } + } + + /* Create path segment */ + if (path != NULL && strlen(path) > 0) { + strpath = apr_psprintf(r->pool, "Path=%s;", path); + } + + /* Create domain segment */ + if (domain != NULL && strlen(domain) > 0) { + /* Domain does NOT like quotes in most browsers, so let's avoid that */ + strdomain = apr_psprintf(r->pool, "Domain=%s;", domain); + } + + /* URL-encode key/value */ + value = ap_escape_urlencoded(r->pool, value); + key = ap_escape_urlencoded(r->pool, key); + + /* Create the header */ + out = apr_psprintf(r->pool, "%s=%s; %s %s %s %s %s", key, value, + secure ? "Secure;" : "", + expires ? strexpires : "", + httponly ? "HttpOnly;" : "", + *strdomain ? strdomain : "", + *strpath ? strpath : ""); + + apr_table_add(r->err_headers_out, "Set-Cookie", out); + return 0; +} + +static apr_uint64_t ap_ntoh64(const apr_uint64_t *input) +{ + apr_uint64_t rval; + unsigned char *data = (unsigned char *)&rval; + if (APR_IS_BIGENDIAN) { + return *input; + } + + data[0] = *input >> 56; + data[1] = *input >> 48; + data[2] = *input >> 40; + data[3] = *input >> 32; + data[4] = *input >> 24; + data[5] = *input >> 16; + data[6] = *input >> 8; + data[7] = *input >> 0; + + return rval; +} + +static int lua_websocket_greet(lua_State *L) +{ + const char *key = NULL; + unsigned char digest[APR_SHA1_DIGESTSIZE]; + apr_sha1_ctx_t sha1; + char *encoded; + int encoded_len; + request_rec *r = ap_lua_check_request_rec(L, 1); + key = apr_table_get(r->headers_in, "Sec-WebSocket-Key"); + if (key != NULL) { + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(03011) + "Websocket: Got websocket key: %s", key); + key = apr_pstrcat(r->pool, key, "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", + NULL); + apr_sha1_init(&sha1); + apr_sha1_update(&sha1, key, strlen(key)); + apr_sha1_final(digest, &sha1); + encoded_len = apr_base64_encode_len(APR_SHA1_DIGESTSIZE); + if (encoded_len) { + encoded = apr_palloc(r->pool, encoded_len); + encoded_len = apr_base64_encode(encoded, (char*) digest, APR_SHA1_DIGESTSIZE); + r->status = 101; + apr_table_setn(r->headers_out, "Upgrade", "websocket"); + apr_table_setn(r->headers_out, "Connection", "Upgrade"); + apr_table_setn(r->headers_out, "Sec-WebSocket-Accept", encoded); + + /* Trick httpd into NOT using the chunked filter, IMPORTANT!!!111*/ + apr_table_setn(r->headers_out, "Transfer-Encoding", "chunked"); + + r->clength = 0; + r->bytes_sent = 0; + r->read_chunked = 0; + ap_rflush(r); + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(03012) + "Websocket: Upgraded from HTTP to Websocket"); + lua_pushboolean(L, 1); + return 1; + } + } + ap_log_rerror(APLOG_MARK, APLOG_NOTICE, 0, r, APLOGNO(02666) + "Websocket: Upgrade from HTTP to Websocket failed"); + return 0; +} + +static apr_status_t lua_websocket_readbytes(conn_rec* c, char* buffer, + apr_off_t len) +{ + apr_bucket_brigade *brigade = apr_brigade_create(c->pool, c->bucket_alloc); + apr_status_t rv; + rv = ap_get_brigade(c->input_filters, brigade, AP_MODE_READBYTES, + APR_BLOCK_READ, len); + if (rv == APR_SUCCESS) { + if (!APR_BRIGADE_EMPTY(brigade)) { + apr_bucket* bucket = APR_BRIGADE_FIRST(brigade); + const char* data = NULL; + apr_size_t data_length = 0; + rv = apr_bucket_read(bucket, &data, &data_length, APR_BLOCK_READ); + if (rv == APR_SUCCESS) { + memcpy(buffer, data, len); + } + apr_bucket_delete(bucket); + } + } + apr_brigade_cleanup(brigade); + return rv; +} + +static int lua_websocket_peek(lua_State *L) +{ + apr_status_t rv; + apr_bucket_brigade *brigade; + + request_rec *r = ap_lua_check_request_rec(L, 1); + + brigade = apr_brigade_create(r->connection->pool, + r->connection->bucket_alloc); + rv = ap_get_brigade(r->connection->input_filters, brigade, + AP_MODE_READBYTES, APR_NONBLOCK_READ, 1); + if (rv == APR_SUCCESS) { + lua_pushboolean(L, 1); + } + else { + lua_pushboolean(L, 0); + } + apr_brigade_cleanup(brigade); + return 1; +} + +static int lua_websocket_read(lua_State *L) +{ + apr_socket_t *sock; + apr_status_t rv; + int do_read = 1; + int n = 0; + apr_size_t len = 1; + apr_size_t plen = 0; + unsigned short payload_short = 0; + apr_uint64_t payload_long = 0; + unsigned char *mask_bytes; + char byte; + int plaintext; + + + request_rec *r = ap_lua_check_request_rec(L, 1); + plaintext = ap_lua_ssl_is_https(r->connection) ? 0 : 1; + + + mask_bytes = apr_pcalloc(r->pool, 4); + sock = ap_get_conn_socket(r->connection); + + while (do_read) { + do_read = 0; + /* Get opcode and FIN bit */ + if (plaintext) { + rv = apr_socket_recv(sock, &byte, &len); + } + else { + rv = lua_websocket_readbytes(r->connection, &byte, 1); + } + if (rv == APR_SUCCESS) { + unsigned char ubyte, fin, opcode, mask, payload; + ubyte = (unsigned char)byte; + /* fin bit is the first bit */ + fin = ubyte >> (CHAR_BIT - 1); + /* opcode is the last four bits (there's 3 reserved bits we don't care about) */ + opcode = ubyte & 0xf; + + /* Get the payload length and mask bit */ + if (plaintext) { + rv = apr_socket_recv(sock, &byte, &len); + } + else { + rv = lua_websocket_readbytes(r->connection, &byte, 1); + } + if (rv == APR_SUCCESS) { + ubyte = (unsigned char)byte; + /* Mask is the first bit */ + mask = ubyte >> (CHAR_BIT - 1); + /* Payload is the last 7 bits */ + payload = ubyte & 0x7f; + plen = payload; + + /* Extended payload? */ + if (payload == 126) { + len = 2; + if (plaintext) { + /* XXX: apr_socket_recv does not receive len bits, only up to len bits! */ + rv = apr_socket_recv(sock, (char*) &payload_short, &len); + } + else { + rv = lua_websocket_readbytes(r->connection, + (char*) &payload_short, 2); + } + payload_short = ntohs(payload_short); + + if (rv == APR_SUCCESS) { + plen = payload_short; + } + else { + return 0; + } + } + /* Super duper extended payload? */ + if (payload == 127) { + len = 8; + if (plaintext) { + rv = apr_socket_recv(sock, (char*) &payload_long, &len); + } + else { + rv = lua_websocket_readbytes(r->connection, + (char*) &payload_long, 8); + } + if (rv == APR_SUCCESS) { + plen = ap_ntoh64(&payload_long); + } + else { + return 0; + } + } + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(03210) + "Websocket: Reading %" APR_SIZE_T_FMT " (%s) bytes, masking is %s. %s", + plen, + (payload >= 126) ? "extra payload" : "no extra payload", + mask ? "on" : "off", + fin ? "This is a final frame" : "more to follow"); + if (mask) { + len = 4; + if (plaintext) { + rv = apr_socket_recv(sock, (char*) mask_bytes, &len); + } + else { + rv = lua_websocket_readbytes(r->connection, + (char*) mask_bytes, 4); + } + if (rv != APR_SUCCESS) { + return 0; + } + } + if (plen < (HUGE_STRING_LEN*1024) && plen > 0) { + apr_size_t remaining = plen; + apr_size_t received; + apr_off_t at = 0; + char *buffer = apr_palloc(r->pool, plen+1); + buffer[plen] = 0; + + if (plaintext) { + while (remaining > 0) { + received = remaining; + rv = apr_socket_recv(sock, buffer+at, &received); + if (received > 0 ) { + remaining -= received; + at += received; + } + } + ap_log_rerror(APLOG_MARK, APLOG_TRACE1, 0, r, + "Websocket: Frame contained %" APR_OFF_T_FMT " bytes, pushed to Lua stack", + at); + } + else { + rv = lua_websocket_readbytes(r->connection, buffer, + remaining); + ap_log_rerror(APLOG_MARK, APLOG_TRACE1, 0, r, + "Websocket: SSL Frame contained %" APR_SIZE_T_FMT " bytes, "\ + "pushed to Lua stack", + remaining); + } + if (mask) { + for (n = 0; n < plen; n++) { + buffer[n] ^= mask_bytes[n%4]; + } + } + + lua_pushlstring(L, buffer, (size_t) plen); /* push to stack */ + lua_pushboolean(L, fin); /* push FIN bit to stack as boolean */ + return 2; + } + + + /* Decide if we need to react to the opcode or not */ + if (opcode == 0x09) { /* ping */ + char frame[2]; + plen = 2; + frame[0] = 0x8A; + frame[1] = 0; + apr_socket_send(sock, frame, &plen); /* Pong! */ + do_read = 1; + } + } + } + } + return 0; +} + + +static int lua_websocket_write(lua_State *L) +{ + const char *string; + apr_status_t rv; + size_t len; + int raw = 0; + char prelude; + request_rec *r = ap_lua_check_request_rec(L, 1); + + if (lua_isboolean(L, 3)) { + raw = lua_toboolean(L, 3); + } + string = lua_tolstring(L, 2, &len); + + if (raw != 1) { + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(03013) + "Websocket: Writing framed message to client"); + + prelude = 0x81; /* text frame, FIN */ + ap_rputc(prelude, r); + if (len < 126) { + ap_rputc(len, r); + } + else if (len < 65535) { + apr_uint16_t slen = len; + ap_rputc(126, r); + slen = htons(slen); + ap_rwrite((char*) &slen, 2, r); + } + else { + apr_uint64_t llen = len; + ap_rputc(127, r); + llen = ap_ntoh64(&llen); /* ntoh doubles as hton */ + ap_rwrite((char*) &llen, 8, r); + } + } + else { + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(03014) + "Websocket: Writing raw message to client"); + } + ap_rwrite(string, len, r); + rv = ap_rflush(r); + if (rv == APR_SUCCESS) { + lua_pushboolean(L, 1); + } + else { + lua_pushboolean(L, 0); + } + return 1; +} + + +static int lua_websocket_close(lua_State *L) +{ + apr_socket_t *sock; + char prelude[2]; + request_rec *r = ap_lua_check_request_rec(L, 1); + + sock = ap_get_conn_socket(r->connection); + + /* Send a header that says: socket is closing. */ + prelude[0] = 0x88; /* closing socket opcode */ + prelude[1] = 0; /* zero length frame */ + ap_rwrite(prelude, 2, r); + + /* Close up tell the MPM and filters to back off */ + apr_socket_close(sock); + r->output_filters = NULL; + r->connection->keepalive = AP_CONN_CLOSE; + return 0; +} + +static int lua_websocket_ping(lua_State *L) +{ + apr_socket_t *sock; + apr_size_t plen; + char prelude[2]; + apr_status_t rv; + request_rec *r = ap_lua_check_request_rec(L, 1); + sock = ap_get_conn_socket(r->connection); + + /* Send a header that says: PING. */ + prelude[0] = 0x89; /* ping opcode */ + prelude[1] = 0; + plen = 2; + apr_socket_send(sock, prelude, &plen); + + + /* Get opcode and FIN bit from pong */ + plen = 2; + rv = apr_socket_recv(sock, prelude, &plen); + if (rv == APR_SUCCESS) { + unsigned char opcode = prelude[0]; + unsigned char len = prelude[1]; + unsigned char mask = len >> 7; + if (mask) len -= 128; + plen = len; + ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(03015) + "Websocket: Got PONG opcode: %x", opcode); + if (opcode == 0x8A) { + lua_pushboolean(L, 1); + } + else { + lua_pushboolean(L, 0); + } + if (plen > 0) { + ap_log_rerror(APLOG_MARK, APLOG_TRACE1, 0, r, + "Websocket: Reading %" APR_SIZE_T_FMT " bytes of PONG", plen); + return 1; + } + if (mask) { + plen = 2; + apr_socket_recv(sock, prelude, &plen); + plen = 2; + apr_socket_recv(sock, prelude, &plen); + } + } + else { + lua_pushboolean(L, 0); + } + return 1; +} + + +#define APLUA_REQ_TRACE(lev) static int req_trace##lev(lua_State *L) \ +{ \ + return req_log_at(L, APLOG_TRACE##lev); \ +} + +APLUA_REQ_TRACE(1) +APLUA_REQ_TRACE(2) +APLUA_REQ_TRACE(3) +APLUA_REQ_TRACE(4) +APLUA_REQ_TRACE(5) +APLUA_REQ_TRACE(6) +APLUA_REQ_TRACE(7) +APLUA_REQ_TRACE(8) + +/* handle r.status = 201 */ +static int req_newindex(lua_State *L) +{ + const char *key; + /* request_rec* r = lua_touserdata(L, lua_upvalueindex(1)); */ + /* const char* key = luaL_checkstring(L, -2); */ + request_rec *r = ap_lua_check_request_rec(L, 1); + key = luaL_checkstring(L, 2); + + if (0 == strcmp("args", key)) { + const char *value = luaL_checkstring(L, 3); + r->args = apr_pstrdup(r->pool, value); + return 0; + } + + if (0 == strcmp("content_type", key)) { + const char *value = luaL_checkstring(L, 3); + ap_set_content_type(r, apr_pstrdup(r->pool, value)); + return 0; + } + + if (0 == strcmp("filename", key)) { + const char *value = luaL_checkstring(L, 3); + r->filename = apr_pstrdup(r->pool, value); + return 0; + } + + if (0 == strcmp("handler", key)) { + const char *value = luaL_checkstring(L, 3); + r->handler = apr_pstrdup(r->pool, value); + return 0; + } + + if (0 == strcmp("proxyreq", key)) { + int value = luaL_checkinteger(L, 3); + r->proxyreq = value; + return 0; + } + + if (0 == strcmp("status", key)) { + int code = luaL_checkinteger(L, 3); + r->status = code; + return 0; + } + + if (0 == strcmp("uri", key)) { + const char *value = luaL_checkstring(L, 3); + r->uri = apr_pstrdup(r->pool, value); + return 0; + } + + if (0 == strcmp("user", key)) { + const char *value = luaL_checkstring(L, 3); + r->user = apr_pstrdup(r->pool, value); + return 0; + } + + lua_pushstring(L, + apr_psprintf(r->pool, + "Property [%s] may not be set on a request_rec", + key)); + lua_error(L); + return 0; +} + + + +/* helper function for walking config trees */ +static void read_cfg_tree(lua_State *L, request_rec *r, ap_directive_t *rcfg) { + int x = 0; + const char* value; + ap_directive_t *cfg; + lua_newtable(L); + + for (cfg = rcfg; cfg; cfg = cfg->next) { + x++; + lua_pushnumber(L, x); + lua_newtable(L); + value = apr_psprintf(r->pool, "%s %s", cfg->directive, cfg->args); + lua_pushstring(L, "directive"); + lua_pushstring(L, value); + lua_settable(L, -3); + lua_pushstring(L, "file"); + lua_pushstring(L, cfg->filename); + lua_settable(L, -3); + lua_pushstring(L, "line"); + lua_pushnumber(L, cfg->line_num); + lua_settable(L, -3); + if (cfg->first_child) { + lua_pushstring(L, "children"); + read_cfg_tree(L, r, cfg->first_child); + lua_settable(L, -3); + } + lua_settable(L, -3); + } +} + +static int lua_ap_get_config(lua_State *L) { + request_rec *r = ap_lua_check_request_rec(L, 1); + read_cfg_tree(L, r, ap_conftree); + + return 1; +} + + +/* Hack, hack, hack...! TODO: Make this actually work properly */ +static int lua_ap_get_active_config(lua_State *L) { + ap_directive_t *subdir; + ap_directive_t *dir = ap_conftree; + request_rec *r = ap_lua_check_request_rec(L, 1); + + for (dir = ap_conftree; dir; dir = dir->next) { + if (ap_strcasestr(dir->directive, "<virtualhost") && dir->first_child) { + for (subdir = dir->first_child; subdir; subdir = subdir->next) { + if (ap_strcasecmp_match(subdir->directive, "servername") && + !ap_strcasecmp_match(r->hostname, subdir->args)) { + read_cfg_tree(L, r, dir->first_child); + return 1; + } + if (ap_strcasecmp_match(subdir->directive, "serveralias") && + !ap_strcasecmp_match(r->hostname, subdir->args)) { + read_cfg_tree(L, r, dir->first_child); + return 1; + } + } + } + } + return 0; +} + + + +static const struct luaL_Reg request_methods[] = { + {"__index", req_dispatch}, + {"__newindex", req_newindex}, + /* {"__newindex", req_set_field}, */ + {NULL, NULL} +}; + + +static const struct luaL_Reg connection_methods[] = { + {NULL, NULL} +}; + +static const char* lua_ap_auth_name(request_rec* r) +{ + const char *name; + name = ap_auth_name(r); + return name ? name : ""; +} + +static const char* lua_ap_get_server_name(request_rec* r) +{ + const char *name; + name = ap_get_server_name(r); + return name ? name : "localhost"; +} + + + + +static const struct luaL_Reg server_methods[] = { + {NULL, NULL} +}; + + +static req_fun_t *makefun(const void *fun, int type, apr_pool_t *pool) +{ + req_fun_t *rft = apr_palloc(pool, sizeof(req_fun_t)); + rft->fun = fun; + rft->type = type; + return rft; +} + +void ap_lua_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, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "write", APR_HASH_KEY_STRING, + makefun(&req_write, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "document_root", APR_HASH_KEY_STRING, + makefun(&req_document_root, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "context_prefix", APR_HASH_KEY_STRING, + makefun(&req_context_prefix, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "context_document_root", APR_HASH_KEY_STRING, + makefun(&req_context_document_root, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "parseargs", APR_HASH_KEY_STRING, + makefun(&req_parseargs, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "parsebody", APR_HASH_KEY_STRING, + makefun(&req_parsebody, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "debug", APR_HASH_KEY_STRING, + makefun(&req_debug, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "info", APR_HASH_KEY_STRING, + makefun(&req_info, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "notice", APR_HASH_KEY_STRING, + makefun(&req_notice, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "warn", APR_HASH_KEY_STRING, + makefun(&req_warn, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "err", APR_HASH_KEY_STRING, + makefun(&req_err, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "crit", APR_HASH_KEY_STRING, + makefun(&req_crit, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "alert", APR_HASH_KEY_STRING, + makefun(&req_alert, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "emerg", APR_HASH_KEY_STRING, + makefun(&req_emerg, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "trace1", APR_HASH_KEY_STRING, + makefun(&req_trace1, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "trace2", APR_HASH_KEY_STRING, + makefun(&req_trace2, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "trace3", APR_HASH_KEY_STRING, + makefun(&req_trace3, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "trace4", APR_HASH_KEY_STRING, + makefun(&req_trace4, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "trace5", APR_HASH_KEY_STRING, + makefun(&req_trace5, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "trace6", APR_HASH_KEY_STRING, + makefun(&req_trace6, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "trace7", APR_HASH_KEY_STRING, + makefun(&req_trace7, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "trace8", APR_HASH_KEY_STRING, + makefun(&req_trace8, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "add_output_filter", APR_HASH_KEY_STRING, + makefun(&req_add_output_filter, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "construct_url", APR_HASH_KEY_STRING, + makefun(&req_construct_url, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "escape_html", APR_HASH_KEY_STRING, + makefun(&req_escape_html, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "ssl_var_lookup", APR_HASH_KEY_STRING, + makefun(&req_ssl_var_lookup, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "is_https", APR_HASH_KEY_STRING, + makefun(&req_ssl_is_https_field, APL_REQ_FUNTYPE_BOOLEAN, p)); + apr_hash_set(dispatch, "assbackwards", APR_HASH_KEY_STRING, + makefun(&req_assbackwards_field, APL_REQ_FUNTYPE_BOOLEAN, p)); + apr_hash_set(dispatch, "status", APR_HASH_KEY_STRING, + makefun(&req_status_field, APL_REQ_FUNTYPE_INT, p)); + apr_hash_set(dispatch, "protocol", APR_HASH_KEY_STRING, + makefun(&req_protocol_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "range", APR_HASH_KEY_STRING, + makefun(&req_range_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "content_type", APR_HASH_KEY_STRING, + 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, APL_REQ_FUNTYPE_STRING, + p)); + apr_hash_set(dispatch, "ap_auth_type", APR_HASH_KEY_STRING, + 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, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "user", APR_HASH_KEY_STRING, + makefun(&req_user_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "filename", APR_HASH_KEY_STRING, + makefun(&req_filename_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "canonical_filename", APR_HASH_KEY_STRING, + 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, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "args", APR_HASH_KEY_STRING, + makefun(&req_args_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "handler", APR_HASH_KEY_STRING, + makefun(&req_handler_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "hostname", APR_HASH_KEY_STRING, + makefun(&req_hostname_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "uri", APR_HASH_KEY_STRING, + makefun(&req_uri_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "the_request", APR_HASH_KEY_STRING, + makefun(&req_the_request_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "log_id", APR_HASH_KEY_STRING, + makefun(&req_log_id_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "useragent_ip", APR_HASH_KEY_STRING, + makefun(&req_useragent_ip_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "method", APR_HASH_KEY_STRING, + makefun(&req_method_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "proxyreq", APR_HASH_KEY_STRING, + makefun(&req_proxyreq_field, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "headers_in", APR_HASH_KEY_STRING, + makefun(&req_headers_in, APL_REQ_FUNTYPE_TABLE, p)); + apr_hash_set(dispatch, "headers_out", APR_HASH_KEY_STRING, + makefun(&req_headers_out, APL_REQ_FUNTYPE_TABLE, p)); + apr_hash_set(dispatch, "err_headers_out", APR_HASH_KEY_STRING, + makefun(&req_err_headers_out, APL_REQ_FUNTYPE_TABLE, p)); + apr_hash_set(dispatch, "notes", APR_HASH_KEY_STRING, + makefun(&req_notes, APL_REQ_FUNTYPE_TABLE, p)); + apr_hash_set(dispatch, "subprocess_env", APR_HASH_KEY_STRING, + makefun(&req_subprocess_env, APL_REQ_FUNTYPE_TABLE, p)); + apr_hash_set(dispatch, "flush", APR_HASH_KEY_STRING, + makefun(&lua_ap_rflush, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "port", APR_HASH_KEY_STRING, + makefun(&req_ap_get_server_port, APL_REQ_FUNTYPE_INT, p)); + apr_hash_set(dispatch, "banner", APR_HASH_KEY_STRING, + makefun(&ap_get_server_banner, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "options", APR_HASH_KEY_STRING, + makefun(&lua_ap_options, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "allowoverrides", APR_HASH_KEY_STRING, + makefun(&lua_ap_allowoverrides, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "started", APR_HASH_KEY_STRING, + makefun(&lua_ap_started, APL_REQ_FUNTYPE_INT, p)); + apr_hash_set(dispatch, "basic_auth_pw", APR_HASH_KEY_STRING, + makefun(&lua_ap_basic_auth_pw, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "limit_req_body", APR_HASH_KEY_STRING, + makefun(&lua_ap_limit_req_body, APL_REQ_FUNTYPE_INT, p)); + apr_hash_set(dispatch, "server_built", APR_HASH_KEY_STRING, + makefun(&ap_get_server_built, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "is_initial_req", APR_HASH_KEY_STRING, + makefun(&lua_ap_is_initial_req, APL_REQ_FUNTYPE_BOOLEAN, p)); + apr_hash_set(dispatch, "remaining", APR_HASH_KEY_STRING, + makefun(&req_remaining_field, APL_REQ_FUNTYPE_INT, p)); + apr_hash_set(dispatch, "some_auth_required", APR_HASH_KEY_STRING, + makefun(&lua_ap_some_auth_required, APL_REQ_FUNTYPE_BOOLEAN, p)); + apr_hash_set(dispatch, "server_name", APR_HASH_KEY_STRING, + makefun(&lua_ap_get_server_name, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "auth_name", APR_HASH_KEY_STRING, + makefun(&lua_ap_auth_name, APL_REQ_FUNTYPE_STRING, p)); + apr_hash_set(dispatch, "sendfile", APR_HASH_KEY_STRING, + makefun(&lua_ap_sendfile, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "dbacquire", APR_HASH_KEY_STRING, + makefun(&lua_db_acquire, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "stat", APR_HASH_KEY_STRING, + makefun(&lua_ap_stat, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "get_direntries", APR_HASH_KEY_STRING, + makefun(&lua_ap_getdir, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "regex", APR_HASH_KEY_STRING, + makefun(&lua_ap_regex, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "usleep", APR_HASH_KEY_STRING, + makefun(&lua_ap_usleep, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "base64_encode", APR_HASH_KEY_STRING, + makefun(&lua_apr_b64encode, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "base64_decode", APR_HASH_KEY_STRING, + makefun(&lua_apr_b64decode, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "md5", APR_HASH_KEY_STRING, + makefun(&lua_apr_md5, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "sha1", APR_HASH_KEY_STRING, + makefun(&lua_apr_sha1, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "htpassword", APR_HASH_KEY_STRING, + makefun(&lua_apr_htpassword, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "touch", APR_HASH_KEY_STRING, + makefun(&lua_apr_touch, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "mkdir", APR_HASH_KEY_STRING, + makefun(&lua_apr_mkdir, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "mkrdir", APR_HASH_KEY_STRING, + makefun(&lua_apr_mkrdir, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "rmdir", APR_HASH_KEY_STRING, + makefun(&lua_apr_rmdir, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "date_parse_rfc", APR_HASH_KEY_STRING, + makefun(&lua_apr_date_parse_rfc, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "escape", APR_HASH_KEY_STRING, + makefun(&lua_ap_escape, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "unescape", APR_HASH_KEY_STRING, + makefun(&lua_ap_unescape, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "mpm_query", APR_HASH_KEY_STRING, + makefun(&lua_ap_mpm_query, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "expr", APR_HASH_KEY_STRING, + makefun(&lua_ap_expr, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "scoreboard_process", APR_HASH_KEY_STRING, + makefun(&lua_ap_scoreboard_process, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "scoreboard_worker", APR_HASH_KEY_STRING, + makefun(&lua_ap_scoreboard_worker, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "clock", APR_HASH_KEY_STRING, + makefun(&lua_ap_clock, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "requestbody", APR_HASH_KEY_STRING, + makefun(&lua_ap_requestbody, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "add_input_filter", APR_HASH_KEY_STRING, + makefun(&lua_ap_add_input_filter, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "module_info", APR_HASH_KEY_STRING, + makefun(&lua_ap_module_info, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "loaded_modules", APR_HASH_KEY_STRING, + makefun(&lua_ap_loaded_modules, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "runtime_dir_relative", APR_HASH_KEY_STRING, + makefun(&lua_ap_runtime_dir_relative, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "server_info", APR_HASH_KEY_STRING, + makefun(&lua_ap_server_info, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "set_document_root", APR_HASH_KEY_STRING, + makefun(&lua_ap_set_document_root, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "set_context_info", APR_HASH_KEY_STRING, + makefun(&lua_ap_set_context_info, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "os_escape_path", APR_HASH_KEY_STRING, + makefun(&lua_ap_os_escape_path, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "escape_logitem", APR_HASH_KEY_STRING, + makefun(&lua_ap_escape_logitem, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "strcmp_match", APR_HASH_KEY_STRING, + makefun(&lua_ap_strcmp_match, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "set_keepalive", APR_HASH_KEY_STRING, + makefun(&lua_ap_set_keepalive, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "make_etag", APR_HASH_KEY_STRING, + makefun(&lua_ap_make_etag, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "send_interim_response", APR_HASH_KEY_STRING, + makefun(&lua_ap_send_interim_response, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "custom_response", APR_HASH_KEY_STRING, + makefun(&lua_ap_custom_response, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "exists_config_define", APR_HASH_KEY_STRING, + makefun(&lua_ap_exists_config_define, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "state_query", APR_HASH_KEY_STRING, + makefun(&lua_ap_state_query, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "get_server_name_for_url", APR_HASH_KEY_STRING, + makefun(&lua_ap_get_server_name_for_url, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "ivm_get", APR_HASH_KEY_STRING, + makefun(&lua_ivm_get, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "ivm_set", APR_HASH_KEY_STRING, + makefun(&lua_ivm_set, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "getcookie", APR_HASH_KEY_STRING, + makefun(&lua_get_cookie, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "setcookie", APR_HASH_KEY_STRING, + makefun(&lua_set_cookie, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "wsupgrade", APR_HASH_KEY_STRING, + makefun(&lua_websocket_greet, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "wsread", APR_HASH_KEY_STRING, + makefun(&lua_websocket_read, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "wspeek", APR_HASH_KEY_STRING, + makefun(&lua_websocket_peek, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "wswrite", APR_HASH_KEY_STRING, + makefun(&lua_websocket_write, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "wsclose", APR_HASH_KEY_STRING, + makefun(&lua_websocket_close, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "wsping", APR_HASH_KEY_STRING, + makefun(&lua_websocket_ping, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "config", APR_HASH_KEY_STRING, + makefun(&lua_ap_get_config, APL_REQ_FUNTYPE_LUACFUN, p)); + apr_hash_set(dispatch, "activeconfig", APR_HASH_KEY_STRING, + makefun(&lua_ap_get_active_config, APL_REQ_FUNTYPE_LUACFUN, p)); + lua_pushlightuserdata(L, dispatch); + lua_setfield(L, LUA_REGISTRYINDEX, "Apache2.Request.dispatch"); + + luaL_newmetatable(L, "Apache2.Request"); /* [metatable] */ + lua_pushvalue(L, -1); + + lua_setfield(L, -2, "__index"); + luaL_setfuncs_compat(L, request_methods); /* [metatable] */ + + lua_pop(L, 2); + + luaL_newmetatable(L, "Apache2.Connection"); /* [metatable] */ + lua_pushvalue(L, -1); + + lua_setfield(L, -2, "__index"); + luaL_setfuncs_compat(L, connection_methods); /* [metatable] */ + + lua_pop(L, 2); + + luaL_newmetatable(L, "Apache2.Server"); /* [metatable] */ + lua_pushvalue(L, -1); + + lua_setfield(L, -2, "__index"); + luaL_setfuncs_compat(L, server_methods); /* [metatable] */ + + lua_pop(L, 2); + +} + +void ap_lua_push_connection(lua_State *L, conn_rec *c) +{ + req_table_t* t; + lua_boxpointer(L, c); + luaL_getmetatable(L, "Apache2.Connection"); + lua_setmetatable(L, -2); + luaL_getmetatable(L, "Apache2.Connection"); + + t = apr_pcalloc(c->pool, sizeof(req_table_t)); + t->t = c->notes; + t->r = NULL; + t->n = "notes"; + ap_lua_push_apr_table(L, t); + lua_setfield(L, -2, "notes"); + + lua_pushstring(L, c->client_ip); + lua_setfield(L, -2, "client_ip"); + + lua_pop(L, 1); +} + + +void ap_lua_push_server(lua_State *L, server_rec *s) +{ + lua_boxpointer(L, s); + luaL_getmetatable(L, "Apache2.Server"); + lua_setmetatable(L, -2); + luaL_getmetatable(L, "Apache2.Server"); + + lua_pushstring(L, s->server_hostname); + lua_setfield(L, -2, "server_hostname"); + + lua_pop(L, 1); +} + +void ap_lua_push_request(lua_State *L, request_rec *r) +{ + lua_boxpointer(L, r); + luaL_getmetatable(L, "Apache2.Request"); + lua_setmetatable(L, -2); +} diff --git a/modules/lua/lua_request.h b/modules/lua/lua_request.h new file mode 100644 index 0000000..a39f4b9 --- /dev/null +++ b/modules/lua/lua_request.h @@ -0,0 +1,58 @@ +/** + * 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. + */ + +#ifndef _LUA_REQUEST_H_ +#define _LUA_REQUEST_H_ + +#include "mod_lua.h" +#include "util_varbuf.h" + +void ap_lua_load_request_lmodule(lua_State *L, apr_pool_t *p); +void ap_lua_push_connection(lua_State *L, conn_rec *r); +void ap_lua_push_server(lua_State *L, server_rec *r); +void ap_lua_push_request(lua_State *L, request_rec *r); + +#define APL_REQ_FUNTYPE_STRING 1 +#define APL_REQ_FUNTYPE_INT 2 +#define APL_REQ_FUNTYPE_TABLE 3 +#define APL_REQ_FUNTYPE_LUACFUN 4 +#define APL_REQ_FUNTYPE_BOOLEAN 5 + +typedef struct +{ + const void *fun; + int type; +} req_fun_t; + + +/* Struct to use as userdata for request_rec tables */ +typedef struct +{ + request_rec *r; /* Request_rec */ + apr_table_t *t; /* apr_table_t* */ + const char *n; /* name of table */ +} req_table_t; + +typedef struct { + int type; + size_t size; + size_t vb_size; + lua_Number number; + struct ap_varbuf vb; +} lua_ivm_object; + +#endif /* !_LUA_REQUEST_H_ */ diff --git a/modules/lua/lua_vmprep.c b/modules/lua/lua_vmprep.c new file mode 100644 index 0000000..001897a --- /dev/null +++ b/modules/lua/lua_vmprep.c @@ -0,0 +1,552 @@ +/** + * 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 "http_log.h" +#include "apr_uuid.h" +#include "lua_config.h" +#include "apr_file_info.h" +#include "mod_auth.h" + +APLOG_USE_MODULE(lua); + +#ifndef AP_LUA_MODULE_EXT +#if defined(NETWARE) +#define AP_LUA_MODULE_EXT ".nlm" +#elif defined(WIN32) +#define AP_LUA_MODULE_EXT ".dll" +#elif (defined(__hpux__) || defined(__hpux)) && !defined(__ia64) +#define AP_LUA_MODULE_EXT ".sl" +#else +#define AP_LUA_MODULE_EXT ".so" +#endif +#endif + +#if APR_HAS_THREADS + apr_thread_mutex_t *ap_lua_mutex; +#endif +extern apr_global_mutex_t *lua_ivm_mutex; + +void ap_lua_init_mutex(apr_pool_t *pool, server_rec *s) +{ + apr_status_t rv; + + /* global IVM mutex */ + rv = apr_global_mutex_child_init(&lua_ivm_mutex, + apr_global_mutex_lockfile(lua_ivm_mutex), + pool); + if (rv != APR_SUCCESS) { + ap_log_error(APLOG_MARK, APLOG_CRIT, rv, s, APLOGNO(03016) + "mod_lua: Failed to reopen mutex lua-ivm-shm in child"); + exit(1); /* bah :( */ + } + + /* Server pool mutex */ +#if APR_HAS_THREADS + apr_thread_mutex_create(&ap_lua_mutex, APR_THREAD_MUTEX_DEFAULT, pool); +#endif +} + +/* forward dec'l from this file */ + +#if 0 +static void pstack_dump(lua_State *L, apr_pool_t *r, int level, + const char *msg) +{ + int i; + int top = lua_gettop(L); + + ap_log_perror(APLOG_MARK, level, 0, r, APLOGNO(03211) + "Lua Stack Dump: [%s]", msg); + + for (i = 1; i <= top; i++) { + int t = lua_type(L, i); + switch (t) { + case LUA_TSTRING:{ + ap_log_perror(APLOG_MARK, level, 0, r, APLOGNO(03212) + "%d: '%s'", i, lua_tostring(L, i)); + break; + } + case LUA_TUSERDATA:{ + ap_log_perror(APLOG_MARK, level, 0, r, APLOGNO(03213) + "%d: userdata", i); + break; + } + case LUA_TLIGHTUSERDATA:{ + ap_log_perror(APLOG_MARK, level, 0, r, APLOGNO(03214) + "%d: lightuserdata", i); + break; + } + case LUA_TNIL:{ + ap_log_perror(APLOG_MARK, level, 0, r, APLOGNO(03215) + "%d: NIL", i); + break; + } + case LUA_TNONE:{ + ap_log_perror(APLOG_MARK, level, 0, r, APLOGNO(03216) + "%d: None", i); + break; + } + case LUA_TBOOLEAN:{ + ap_log_perror(APLOG_MARK, level, 0, r, APLOGNO(03217) + "%d: %s", + i, lua_toboolean(L, i) ? "true" : "false"); + break; + } + case LUA_TNUMBER:{ + ap_log_perror(APLOG_MARK, level, 0, r, APLOGNO(03218) + "%d: %g", i, lua_tonumber(L, i)); + break; + } + case LUA_TTABLE:{ + ap_log_perror(APLOG_MARK, level, 0, r, APLOGNO(03219) + "%d: <table>", i); + break; + } + case LUA_TTHREAD:{ + ap_log_perror(APLOG_MARK, level, 0, r, APLOGNO(03220) + "%d: <thread>", i); + break; + } + case LUA_TFUNCTION:{ + ap_log_perror(APLOG_MARK, level, 0, r, APLOGNO(03221) + "%d: <function>", i); + break; + } + default:{ + ap_log_perror(APLOG_MARK, level, 0, r, APLOGNO(03222) + "%d: unknown: [%s]", i, lua_typename(L, i)); + break; + } + } + } +} +#endif + +/* BEGIN modules*/ + +/* BEGIN apache lmodule */ + +#define makeintegerfield(L, n) lua_pushinteger(L, n); lua_setfield(L, -2, #n) + +void ap_lua_load_apache2_lmodule(lua_State *L) +{ + lua_getglobal(L, "package"); + lua_getfield(L, -1, "loaded"); + lua_newtable(L); + lua_setfield(L, -2, "apache2"); + lua_setglobal(L, "apache2"); + lua_pop(L, 1); /* empty stack */ + + lua_getglobal(L, "apache2"); + + lua_pushstring(L, ap_get_server_banner()); + lua_setfield(L, -2, "version"); + + makeintegerfield(L, OK); + makeintegerfield(L, DECLINED); + makeintegerfield(L, DONE); + makeintegerfield(L, HTTP_MOVED_TEMPORARILY); + makeintegerfield(L, PROXYREQ_NONE); + makeintegerfield(L, PROXYREQ_PROXY); + makeintegerfield(L, PROXYREQ_REVERSE); + makeintegerfield(L, PROXYREQ_RESPONSE); + makeintegerfield(L, PROXYREQ_RESPONSE); + makeintegerfield(L, AUTHZ_DENIED); + makeintegerfield(L, AUTHZ_GRANTED); + makeintegerfield(L, AUTHZ_NEUTRAL); + makeintegerfield(L, AUTHZ_GENERAL_ERROR); + makeintegerfield(L, AUTHZ_DENIED_NO_USER); + + /* + makeintegerfield(L, HTTP_CONTINUE); + makeintegerfield(L, HTTP_SWITCHING_PROTOCOLS); + makeintegerfield(L, HTTP_PROCESSING); + makeintegerfield(L, HTTP_OK); + makeintegerfield(L, HTTP_CREATED); + makeintegerfield(L, HTTP_ACCEPTED); + makeintegerfield(L, HTTP_NON_AUTHORITATIVE); + makeintegerfield(L, HTTP_NO_CONTENT); + makeintegerfield(L, HTTP_RESET_CONTENT); + makeintegerfield(L, HTTP_PARTIAL_CONTENT); + makeintegerfield(L, HTTP_MULTI_STATUS); + makeintegerfield(L, HTTP_ALREADY_REPORTED); + makeintegerfield(L, HTTP_IM_USED); + makeintegerfield(L, HTTP_MULTIPLE_CHOICES); + makeintegerfield(L, HTTP_MOVED_PERMANENTLY); + makeintegerfield(L, HTTP_MOVED_TEMPORARILY); + makeintegerfield(L, HTTP_SEE_OTHER); + makeintegerfield(L, HTTP_NOT_MODIFIED); + makeintegerfield(L, HTTP_USE_PROXY); + makeintegerfield(L, HTTP_TEMPORARY_REDIRECT); + makeintegerfield(L, HTTP_PERMANENT_REDIRECT); + makeintegerfield(L, HTTP_BAD_REQUEST); + makeintegerfield(L, HTTP_UNAUTHORIZED); + makeintegerfield(L, HTTP_PAYMENT_REQUIRED); + makeintegerfield(L, HTTP_FORBIDDEN); + makeintegerfield(L, HTTP_NOT_FOUND); + makeintegerfield(L, HTTP_METHOD_NOT_ALLOWED); + makeintegerfield(L, HTTP_NOT_ACCEPTABLE); + makeintegerfield(L, HTTP_PROXY_AUTHENTICATION_REQUIRED); + makeintegerfield(L, HTTP_REQUEST_TIME_OUT); + makeintegerfield(L, HTTP_CONFLICT); + makeintegerfield(L, HTTP_GONE); + makeintegerfield(L, HTTP_LENGTH_REQUIRED); + makeintegerfield(L, HTTP_PRECONDITION_FAILED); + makeintegerfield(L, HTTP_REQUEST_ENTITY_TOO_LARGE); + makeintegerfield(L, HTTP_REQUEST_URI_TOO_LARGE); + makeintegerfield(L, HTTP_UNSUPPORTED_MEDIA_TYPE); + makeintegerfield(L, HTTP_RANGE_NOT_SATISFIABLE); + makeintegerfield(L, HTTP_EXPECTATION_FAILED); + makeintegerfield(L, HTTP_UNPROCESSABLE_ENTITY); + makeintegerfield(L, HTTP_LOCKED); + makeintegerfield(L, HTTP_FAILED_DEPENDENCY); + makeintegerfield(L, HTTP_UPGRADE_REQUIRED); + makeintegerfield(L, HTTP_PRECONDITION_REQUIRED); + makeintegerfield(L, HTTP_TOO_MANY_REQUESTS); + makeintegerfield(L, HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE); + makeintegerfield(L, HTTP_INTERNAL_SERVER_ERROR); + makeintegerfield(L, HTTP_NOT_IMPLEMENTED); + makeintegerfield(L, HTTP_BAD_GATEWAY); + makeintegerfield(L, HTTP_SERVICE_UNAVAILABLE); + makeintegerfield(L, HTTP_GATEWAY_TIME_OUT); + makeintegerfield(L, HTTP_VERSION_NOT_SUPPORTED); + makeintegerfield(L, HTTP_VARIANT_ALSO_VARIES); + makeintegerfield(L, HTTP_INSUFFICIENT_STORAGE); + makeintegerfield(L, HTTP_LOOP_DETECTED); + makeintegerfield(L, HTTP_NOT_EXTENDED); + makeintegerfield(L, HTTP_NETWORK_AUTHENTICATION_REQUIRED); + */ +} + +/* END apache2 lmodule */ + +/* END library functions */ + +/* callback for cleaning up a lua vm when pool is closed */ +static apr_status_t cleanup_lua(void *l) +{ + AP_DEBUG_ASSERT(l != NULL); + lua_close((lua_State *) l); + return APR_SUCCESS; +} + +static apr_status_t server_cleanup_lua(void *resource, void *params, apr_pool_t *pool) +{ + ap_lua_server_spec* spec = (ap_lua_server_spec*) resource; + AP_DEBUG_ASSERT(spec != NULL); + if (spec->L != NULL) { + lua_close((lua_State *) spec->L); + } + return APR_SUCCESS; +} + +/* + munge_path(L, + "path", + "?.lua", + "./?.lua", + lifecycle_pool, + spec->package_paths, + spec->file); +*/ +/** + * field -> "path" or "cpath" + * sub_pat -> "?.lua" + * rep_pat -> "./?.lua" + * pool -> lifecycle pool for allocations + * paths -> things to add + * file -> ??? + */ +static void munge_path(lua_State *L, + const char *field, + const char *sub_pat, + const char *rep_pat, + apr_pool_t *pool, + apr_array_header_t *paths, + const char *file) +{ + const char *current; + const char *parent_dir; + const char *pattern; + const char *modified; + char *part; + + lua_getglobal(L, "package"); + lua_getfield(L, -1, field); + + current = lua_tostring(L, -1); + + parent_dir = ap_make_dirstr_parent(pool, file); + + pattern = apr_pstrcat(pool, parent_dir, sub_pat, NULL); + + luaL_gsub(L, current, rep_pat, pattern); + lua_setfield(L, -3, field); + lua_getfield(L, -2, field); + modified = lua_tostring(L, -1); + + + lua_pop(L, 2); + + part = apr_pstrcat(pool, modified, ";", apr_array_pstrcat(pool, paths, ';'), + NULL); + + lua_pushstring(L, part); + lua_setfield(L, -2, field); + lua_pop(L, 1); /* pop "package" off the stack */ +} + +#ifdef AP_ENABLE_LUAJIT +static int loadjitmodule(lua_State *L, apr_pool_t *lifecycle_pool) +{ + lua_getglobal(L, "require"); + lua_pushliteral(L, "jit."); + lua_pushvalue(L, -3); + lua_concat(L, 2); + if (lua_pcall(L, 1, 1, 0)) { + const char *msg = lua_tostring(L, -1); + ap_log_perror(APLOG_MARK, APLOG_DEBUG, 0, lifecycle_pool, APLOGNO(01480) + "Failed to init LuaJIT: %s", msg); + return 1; + } + lua_getfield(L, -1, "start"); + lua_remove(L, -2); /* drop module table */ + return 0; +} + +#endif + +static apr_status_t vm_construct(lua_State **vm, void *params, apr_pool_t *lifecycle_pool) +{ + lua_State* L; + + ap_lua_vm_spec *spec = params; + + L = luaL_newstate(); +#ifdef AP_ENABLE_LUAJIT + luaopen_jit(L); +#endif + luaL_openlibs(L); + if (spec->package_paths) { + munge_path(L, + "path", "?.lua", "./?.lua", + lifecycle_pool, + spec->package_paths, + spec->file); + } + if (spec->package_cpaths) { + munge_path(L, + "cpath", "?" AP_LUA_MODULE_EXT, "./?" AP_LUA_MODULE_EXT, + lifecycle_pool, + spec->package_cpaths, + spec->file); + } + + if (spec->cb) { + spec->cb(L, lifecycle_pool, spec->cb_arg); + } + + + if (spec->bytecode && spec->bytecode_len > 0) { + luaL_loadbuffer(L, spec->bytecode, spec->bytecode_len, spec->file); + lua_pcall(L, 0, LUA_MULTRET, 0); + } + else { + int rc; + ap_log_perror(APLOG_MARK, APLOG_DEBUG, 0, lifecycle_pool, APLOGNO(01481) + "loading lua file %s", spec->file); + rc = luaL_loadfile(L, spec->file); + if (rc != 0) { + ap_log_perror(APLOG_MARK, APLOG_ERR, 0, lifecycle_pool, APLOGNO(01482) + "Error loading %s: %s", spec->file, + rc == LUA_ERRMEM ? "memory allocation error" + : lua_tostring(L, 0)); + return APR_EBADF; + } + if ( lua_pcall(L, 0, LUA_MULTRET, 0) == LUA_ERRRUN ) { + ap_log_perror(APLOG_MARK, APLOG_ERR, 0, lifecycle_pool, APLOGNO(02613) + "Error loading %s: %s", spec->file, + lua_tostring(L, -1)); + return APR_EBADF; + } + } + +#ifdef AP_ENABLE_LUAJIT + loadjitmodule(L, lifecycle_pool); +#endif + lua_pushlightuserdata(L, lifecycle_pool); + lua_setfield(L, LUA_REGISTRYINDEX, "Apache2.Wombat.pool"); + *vm = L; + + return APR_SUCCESS; +} + +static ap_lua_vm_spec* copy_vm_spec(apr_pool_t* pool, ap_lua_vm_spec* spec) +{ + ap_lua_vm_spec* copied_spec = apr_pcalloc(pool, sizeof(ap_lua_vm_spec)); + copied_spec->bytecode_len = spec->bytecode_len; + copied_spec->bytecode = apr_pstrdup(pool, spec->bytecode); + copied_spec->cb = spec->cb; + copied_spec->cb_arg = NULL; + copied_spec->file = apr_pstrdup(pool, spec->file); + copied_spec->package_cpaths = apr_array_copy(pool, spec->package_cpaths); + copied_spec->package_paths = apr_array_copy(pool, spec->package_paths); + copied_spec->pool = pool; + copied_spec->scope = AP_LUA_SCOPE_SERVER; + copied_spec->codecache = spec->codecache; + return copied_spec; +} + +static apr_status_t server_vm_construct(lua_State **resource, void *params, apr_pool_t *pool) +{ + lua_State* L; + ap_lua_server_spec* spec = apr_pcalloc(pool, sizeof(ap_lua_server_spec)); + *resource = NULL; + if (vm_construct(&L, params, pool) == APR_SUCCESS) { + spec->finfo = apr_pcalloc(pool, sizeof(ap_lua_finfo)); + if (L != NULL) { + spec->L = L; + *resource = (void*) spec; + lua_pushlightuserdata(L, spec); + lua_setfield(L, LUA_REGISTRYINDEX, "Apache2.Lua.server_spec"); + return APR_SUCCESS; + } + } + return APR_EGENERAL; +} + +/** + * Function used to create a lua_State instance bound into the web + * server in the appropriate scope. + */ +lua_State *ap_lua_get_lua_state(apr_pool_t *lifecycle_pool, + ap_lua_vm_spec *spec, request_rec* r) +{ + lua_State *L = NULL; + ap_lua_finfo *cache_info = NULL; + int tryCache = 0; + + if (spec->scope == AP_LUA_SCOPE_SERVER) { + char *hash; + apr_reslist_t* reslist = NULL; + ap_lua_server_spec* sspec = NULL; + hash = apr_psprintf(r->pool, "reslist:%s", spec->file); +#if APR_HAS_THREADS + apr_thread_mutex_lock(ap_lua_mutex); +#endif + if (apr_pool_userdata_get((void **)&reslist, hash, + r->server->process->pool) == APR_SUCCESS) { + if (reslist != NULL) { + if (apr_reslist_acquire(reslist, (void**) &sspec) == APR_SUCCESS) { + L = sspec->L; + cache_info = sspec->finfo; + } + } + } + if (L == NULL) { + ap_lua_vm_spec* server_spec = copy_vm_spec(r->server->process->pool, spec); + if ( + apr_reslist_create(&reslist, spec->vm_min, spec->vm_max, spec->vm_max, 0, + (apr_reslist_constructor) server_vm_construct, + (apr_reslist_destructor) server_cleanup_lua, + server_spec, r->server->process->pool) + == APR_SUCCESS && reslist != NULL) { + apr_pool_userdata_set(reslist, hash, NULL, + r->server->process->pool); + if (apr_reslist_acquire(reslist, (void**) &sspec) == APR_SUCCESS) { + L = sspec->L; + cache_info = sspec->finfo; + } + else { +#if APR_HAS_THREADS + apr_thread_mutex_unlock(ap_lua_mutex); +#endif + return NULL; + } + } + } +#if APR_HAS_THREADS + apr_thread_mutex_unlock(ap_lua_mutex); +#endif + } + else { + if (apr_pool_userdata_get((void **)&L, spec->file, + lifecycle_pool) != APR_SUCCESS) { + L = NULL; + } + } + if (L == NULL) { + ap_log_perror(APLOG_MARK, APLOG_DEBUG, 0, lifecycle_pool, APLOGNO(01483) + "creating lua_State with file %s", spec->file); + /* not available, so create */ + + if (!vm_construct(&L, spec, lifecycle_pool)) { + AP_DEBUG_ASSERT(L != NULL); + apr_pool_userdata_set(L, spec->file, cleanup_lua, lifecycle_pool); + } + } + + if (spec->codecache == AP_LUA_CACHE_FOREVER || (spec->bytecode && spec->bytecode_len > 0)) { + tryCache = 1; + } + else { + char* mkey; + if (spec->scope != AP_LUA_SCOPE_SERVER) { + mkey = apr_psprintf(r->pool, "ap_lua_modified:%s", spec->file); + apr_pool_userdata_get((void **)&cache_info, mkey, lifecycle_pool); + if (cache_info == NULL) { + cache_info = apr_pcalloc(lifecycle_pool, sizeof(ap_lua_finfo)); + apr_pool_userdata_set((void*) cache_info, mkey, NULL, lifecycle_pool); + } + } + if (spec->codecache == AP_LUA_CACHE_STAT) { + apr_finfo_t lua_finfo; + apr_stat(&lua_finfo, spec->file, APR_FINFO_MTIME|APR_FINFO_SIZE, lifecycle_pool); + + /* On first visit, modified will be zero, but that's fine - The file is + loaded in the vm_construct function. + */ + if ((cache_info->modified == lua_finfo.mtime && cache_info->size == lua_finfo.size) + || cache_info->modified == 0) { + tryCache = 1; + } + cache_info->modified = lua_finfo.mtime; + cache_info->size = lua_finfo.size; + } + else if (spec->codecache == AP_LUA_CACHE_NEVER) { + if (cache_info->runs == 0) + tryCache = 1; + } + cache_info->runs++; + } + if (tryCache == 0 && spec->scope != AP_LUA_SCOPE_ONCE) { + int rc; + ap_log_perror(APLOG_MARK, APLOG_DEBUG, 0, lifecycle_pool, APLOGNO(02332) + "(re)loading lua file %s", spec->file); + rc = luaL_loadfile(L, spec->file); + if (rc != 0) { + ap_log_perror(APLOG_MARK, APLOG_ERR, 0, lifecycle_pool, APLOGNO(02333) + "Error loading %s: %s", spec->file, + rc == LUA_ERRMEM ? "memory allocation error" + : lua_tostring(L, 0)); + return 0; + } + lua_pcall(L, 0, LUA_MULTRET, 0); + } + + return L; +} diff --git a/modules/lua/lua_vmprep.h b/modules/lua/lua_vmprep.h new file mode 100644 index 0000000..e46ac9b --- /dev/null +++ b/modules/lua/lua_vmprep.h @@ -0,0 +1,147 @@ +/** + * 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 "lua.h" +#include "lauxlib.h" +#include "lualib.h" + +#include "httpd.h" + +#include "apr_thread_rwlock.h" +#include "apr_strings.h" +#include "apr_tables.h" +#include "apr_hash.h" +#include "apr_buckets.h" +#include "apr_file_info.h" +#include "apr_time.h" +#include "apr_pools.h" +#include "apr_reslist.h" + + +#ifndef VMPREP_H +#define VMPREP_H + +#define AP_LUA_SCOPE_UNSET 0 +#define AP_LUA_SCOPE_ONCE 1 +#define AP_LUA_SCOPE_REQUEST 2 +#define AP_LUA_SCOPE_CONN 3 +#define AP_LUA_SCOPE_THREAD 4 +#define AP_LUA_SCOPE_SERVER 5 + +#define AP_LUA_CACHE_UNSET 0 +#define AP_LUA_CACHE_NEVER 1 +#define AP_LUA_CACHE_STAT 2 +#define AP_LUA_CACHE_FOREVER 3 + +#define AP_LUA_FILTER_INPUT 1 +#define AP_LUA_FILTER_OUTPUT 2 + +typedef void (*ap_lua_state_open_callback) (lua_State *L, apr_pool_t *p, + void *ctx); +/** + * Specification for a lua virtual machine + */ +typedef struct +{ + /* NEED TO ADD ADDITIONAL PACKAGE PATHS AS PART OF SPEC INSTEAD OF DIR CONFIG */ + apr_array_header_t *package_paths; + apr_array_header_t *package_cpaths; + + /* name of base file to load in the vm */ + const char *file; + + /* APL_SCOPE_ONCE | APL_SCOPE_REQUEST | APL_SCOPE_CONN | APL_SCOPE_THREAD | APL_SCOPE_SERVER */ + int scope; + unsigned int vm_min; + unsigned int vm_max; + + ap_lua_state_open_callback cb; + void* cb_arg; + + /* pool to use for lifecycle if APL_SCOPE_ONCE is set, otherwise unused */ + apr_pool_t *pool; + + /* Pre-compiled Lua Byte code to load directly. If bytecode_len is >0, + * the file part of this structure is ignored for loading purposes, but + * it is used for error messages. + */ + const char *bytecode; + apr_size_t bytecode_len; + + int codecache; +} ap_lua_vm_spec; + +typedef struct +{ + const char *function_name; + const char *file_name; + int scope; + ap_regex_t *uri_pattern; + const char *bytecode; + apr_size_t bytecode_len; + int codecache; +} ap_lua_mapped_handler_spec; + +typedef struct +{ + const char *function_name; + const char *file_name; + const char* filter_name; + int direction; /* AP_LUA_FILTER_INPUT | AP_LUA_FILTER_OUTPUT */ +} ap_lua_filter_handler_spec; + +typedef struct { + apr_size_t runs; + apr_time_t modified; + apr_off_t size; +} ap_lua_finfo; + +typedef struct { + lua_State* L; + ap_lua_finfo* finfo; +} ap_lua_server_spec; + +/** + * Fake out addition of the "apache2" module + */ +void ap_lua_load_apache2_lmodule(lua_State *L); + +/* + * alternate means of getting lua_State (preferred eventually) + * Obtain a lua_State which has loaded file and is associated with lifecycle_pool + * If one exists, will return extant one, otherwise will create, attach, and return + * This does no locking around the lua_State, so if the pool is shared between + * threads, locking is up the client. + * + * @lifecycle_pool -> pool whose lifeycle controls the lua_State + * @file file to be opened, also used as a key for uniquing lua_States + * @cb callback for vm initialization called *before* the file is opened + * @ctx a baton passed to cb + */ +lua_State *ap_lua_get_lua_state(apr_pool_t *lifecycle_pool, + ap_lua_vm_spec *spec, request_rec* r); + +#if APR_HAS_THREADS || defined(DOXYGEN) +/* + * Initialize mod_lua mutex. + * @pool pool for mutex + * @s server_rec for logging + */ +void ap_lua_init_mutex(apr_pool_t *pool, server_rec *s); +#endif + +#endif diff --git a/modules/lua/mod_lua.c b/modules/lua/mod_lua.c new file mode 100644 index 0000000..6d79199 --- /dev/null +++ b/modules/lua/mod_lua.c @@ -0,0 +1,2174 @@ +/** + * 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("<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, 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) { + 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, + void *mconfig, + const char *line) +{ + const char *function = NULL; + ap_lua_mapped_handler_spec *spec; + int when = APR_HOOK_MIDDLE; + const char *endp = ap_strrchr_c(line, '>'); + + if (endp == NULL) { + return apr_pstrcat(cmd->pool, cmd->cmd->name, + "> directive missing closing '>'", NULL); + } + + line = apr_pstrndup(cmd->temp_pool, line, endp - line); + + if (line[0]) { + const char *word; + word = ap_getword_conf(cmd->temp_pool, &line); + if (*word) { + function = apr_pstrdup(cmd->pool, word); + } + word = ap_getword_conf(cmd->temp_pool, &line); + if (*word) { + if (!strcasecmp("early", word)) { + when = AP_LUA_HOOK_FIRST; + } + else if (!strcasecmp("late", word)) { + when = AP_LUA_HOOK_LAST; + } + else { + return apr_pstrcat(cmd->pool, cmd->cmd->name, + "> 2nd argument must be 'early' or 'late'", NULL); + } + } + } + + spec = apr_pcalloc(cmd->pool, sizeof(ap_lua_mapped_handler_spec)); + + { + cr_ctx ctx; + lua_State *lvm; + char *tmp; + int rv; + ap_directive_t **current; + hack_section_baton *baton; + + spec->file_name = apr_psprintf(cmd->pool, "%s:%u", + cmd->config_file->name, + cmd->config_file->line_number); + if (function) { + spec->function_name = (char *) function; + } + else { + function = NULL; + } + + ctx.cmd = cmd; + tmp = apr_pstrdup(cmd->pool, cmd->err_directive->directive + 1); + ap_str_tolower(tmp); + ctx.endstr = tmp; + ctx.cfp = cmd->config_file; + ctx.startline = cmd->config_file->line_number; + + /* This lua State is used only to compile the input strings -> bytecode, so we don't need anything extra. */ + lvm = luaL_newstate(); + + lua_settop(lvm, 0); + + rv = lua_load(lvm, direct_chunkreader, &ctx, spec->file_name); + + if (rv != 0) { + const char *errstr = apr_pstrcat(cmd->pool, "Lua Error:", + lua_tostring(lvm, -1), NULL); + lua_close(lvm); + return errstr; + } + else { + luaL_Buffer b; + luaL_buffinit(lvm, &b); + lua_dump(lvm, ldump_writer, &b); + luaL_pushresult(&b); + spec->bytecode_len = lua_rawlen(lvm, -1); + spec->bytecode = apr_pstrmemdup(cmd->pool, lua_tostring(lvm, -1), + spec->bytecode_len); + lua_close(lvm); + } + + current = mconfig; + + /* Here, we have to replace our current config node for the next pass */ + if (!*current) { + *current = apr_pcalloc(cmd->pool, sizeof(**current)); + } + + baton = apr_pcalloc(cmd->pool, sizeof(hack_section_baton)); + baton->name = name; + baton->spec = spec; + baton->apr_hook_when = when; + + (*current)->filename = cmd->config_file->name; + (*current)->line_num = cmd->config_file->line_number; + (*current)->directive = apr_pstrdup(cmd->pool, "Lua_____ByteCodeHack"); + (*current)->args = NULL; + (*current)->data = baton; + } + + return NULL; +} + +static const char *register_named_file_function_hook(const char *name, + cmd_parms *cmd, + void *_cfg, + const char *file, + const char *function, + int apr_hook_when) +{ + ap_lua_mapped_handler_spec *spec; + ap_lua_dir_cfg *cfg = (ap_lua_dir_cfg *) _cfg; + const char *key = apr_psprintf(cmd->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) { + 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); + } + + spec = apr_pcalloc(cmd->pool, sizeof(ap_lua_mapped_handler_spec)); + spec->file_name = apr_pstrdup(cmd->pool, file); + spec->function_name = apr_pstrdup(cmd->pool, function); + spec->scope = cfg->vm_scope; + + *(ap_lua_mapped_handler_spec **) apr_array_push(hook_specs) = spec; + return NULL; +} +static const char *register_mapped_file_function_hook(const char *pattern, + cmd_parms *cmd, + void *_cfg, + const char *file, + const char *function) +{ + ap_lua_mapped_handler_spec *spec; + ap_lua_dir_cfg *cfg = (ap_lua_dir_cfg *) _cfg; + ap_regex_t *regex = apr_pcalloc(cmd->pool, sizeof(ap_regex_t)); + if (ap_regcomp(regex, pattern,0)) { + return "Invalid regex pattern!"; + } + + spec = apr_pcalloc(cmd->pool, sizeof(ap_lua_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->uri_pattern = regex; + + *(ap_lua_mapped_handler_spec **) apr_array_push(cfg->mapped_handlers) = spec; + return NULL; +} +static const char *register_filter_function_hook(const char *filter, + cmd_parms *cmd, + void *_cfg, + const char *file, + const char *function, + int direction) +{ + ap_lua_filter_handler_spec *spec; + ap_lua_dir_cfg *cfg = (ap_lua_dir_cfg *) _cfg; + + spec = apr_pcalloc(cmd->pool, sizeof(ap_lua_filter_handler_spec)); + spec->file_name = apr_pstrdup(cmd->pool, file); + spec->function_name = apr_pstrdup(cmd->pool, function); + spec->filter_name = filter; + + *(ap_lua_filter_handler_spec **) apr_array_push(cfg->mapped_filters) = spec; + /* TODO: Make it work on other types than just AP_FTYPE_RESOURCE? */ + if (direction == AP_LUA_FILTER_OUTPUT) { + spec->direction = AP_LUA_FILTER_OUTPUT; + ap_register_output_filter_protocol(filter, lua_output_filter_handle, NULL, AP_FTYPE_RESOURCE, + AP_FILTER_PROTO_CHANGE|AP_FILTER_PROTO_CHANGE_LENGTH); + } + else { + spec->direction = AP_LUA_FILTER_INPUT; + ap_register_input_filter(filter, lua_input_filter_handle, NULL, AP_FTYPE_RESOURCE); + } + return NULL; +} +/* disabled (see reference below) +static int lua_check_user_id_harness_first(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "check_user_id", AP_LUA_HOOK_FIRST); +} +*/ +static int lua_check_user_id_harness(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "check_user_id", APR_HOOK_MIDDLE); +} +/* disabled (see reference below) +static int lua_check_user_id_harness_last(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "check_user_id", AP_LUA_HOOK_LAST); +} +*/ + +static int lua_translate_name_harness_first(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "translate_name", AP_LUA_HOOK_FIRST); +} +static int lua_translate_name_harness(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "translate_name", APR_HOOK_MIDDLE); +} +static int lua_translate_name_harness_last(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "translate_name", AP_LUA_HOOK_LAST); +} + +static int lua_fixup_harness(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "fixups", APR_HOOK_MIDDLE); +} + +static int lua_map_to_storage_harness(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "map_to_storage", APR_HOOK_MIDDLE); +} + +static int lua_type_checker_harness(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "type_checker", APR_HOOK_MIDDLE); +} + +static int lua_access_checker_harness_first(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "access_checker", AP_LUA_HOOK_FIRST); +} +static int lua_access_checker_harness(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "access_checker", APR_HOOK_MIDDLE); +} +static int lua_access_checker_harness_last(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "access_checker", AP_LUA_HOOK_LAST); +} + +static int lua_auth_checker_harness_first(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "auth_checker", AP_LUA_HOOK_FIRST); +} +static int lua_auth_checker_harness(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "auth_checker", APR_HOOK_MIDDLE); +} +static int lua_auth_checker_harness_last(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "auth_checker", AP_LUA_HOOK_LAST); +} +static void lua_insert_filter_harness(request_rec *r) +{ + /* ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(03223) + * "LuaHookInsertFilter not yet implemented"); */ +} + +static int lua_log_transaction_harness(request_rec *r) +{ + return lua_request_rec_hook_harness(r, "log_transaction", APR_HOOK_FIRST); +} + +static int lua_quick_harness(request_rec *r, int lookup) +{ + if (lookup) { + return DECLINED; + } + return lua_request_rec_hook_harness(r, "quick", APR_HOOK_MIDDLE); +} + +static const char *register_translate_name_hook(cmd_parms *cmd, void *_cfg, + const char *file, + const char *function, + const char *when) +{ + const char *err = ap_check_cmd_context(cmd, NOT_IN_DIRECTORY|NOT_IN_FILES| + NOT_IN_HTACCESS); + int apr_hook_when = APR_HOOK_MIDDLE; + if (err) { + return err; + } + + if (when) { + if (!strcasecmp(when, "early")) { + apr_hook_when = AP_LUA_HOOK_FIRST; + } + else if (!strcasecmp(when, "late")) { + apr_hook_when = AP_LUA_HOOK_LAST; + } + else { + return "Third argument must be 'early' or 'late'"; + } + } + + return register_named_file_function_hook("translate_name", cmd, _cfg, + file, function, apr_hook_when); +} + +static const char *register_translate_name_block(cmd_parms *cmd, void *_cfg, + const char *line) +{ + return register_named_block_function_hook("translate_name", cmd, _cfg, + line); +} + + +static const char *register_fixups_hook(cmd_parms *cmd, void *_cfg, + const char *file, + const char *function) +{ + return register_named_file_function_hook("fixups", cmd, _cfg, file, + function, APR_HOOK_MIDDLE); +} +static const char *register_fixups_block(cmd_parms *cmd, void *_cfg, + const char *line) +{ + return register_named_block_function_hook("fixups", cmd, _cfg, line); +} + +static const char *register_map_to_storage_hook(cmd_parms *cmd, void *_cfg, + const char *file, + const char *function) +{ + return register_named_file_function_hook("map_to_storage", cmd, _cfg, + file, function, APR_HOOK_MIDDLE); +} + +static const char *register_log_transaction_hook(cmd_parms *cmd, void *_cfg, + const char *file, + const char *function) +{ + return register_named_file_function_hook("log_transaction", cmd, _cfg, + file, function, APR_HOOK_FIRST); +} + +static const char *register_map_to_storage_block(cmd_parms *cmd, void *_cfg, + const char *line) +{ + return register_named_block_function_hook("map_to_storage", cmd, _cfg, + line); +} + + +static const char *register_check_user_id_hook(cmd_parms *cmd, void *_cfg, + const char *file, + const char *function, + const char *when) +{ + int apr_hook_when = APR_HOOK_MIDDLE; +/* XXX: This does not currently work!! + if (when) { + if (!strcasecmp(when, "early")) { + apr_hook_when = AP_LUA_HOOK_FIRST; + } + else if (!strcasecmp(when, "late")) { + apr_hook_when = AP_LUA_HOOK_LAST; + } + else { + return "Third argument must be 'early' or 'late'"; + } + } +*/ + return register_named_file_function_hook("check_user_id", cmd, _cfg, file, + function, apr_hook_when); +} +static const char *register_check_user_id_block(cmd_parms *cmd, void *_cfg, + const char *line) +{ + return register_named_block_function_hook("check_user_id", cmd, _cfg, + line); +} + +static const char *register_type_checker_hook(cmd_parms *cmd, void *_cfg, + const char *file, + const char *function) +{ + return register_named_file_function_hook("type_checker", cmd, _cfg, file, + function, APR_HOOK_MIDDLE); +} +static const char *register_type_checker_block(cmd_parms *cmd, void *_cfg, + const char *line) +{ + return register_named_block_function_hook("type_checker", cmd, _cfg, + line); +} + +static const char *register_access_checker_hook(cmd_parms *cmd, void *_cfg, + const char *file, + const char *function, + const char *when) +{ + int apr_hook_when = APR_HOOK_MIDDLE; + + if (when) { + if (!strcasecmp(when, "early")) { + apr_hook_when = AP_LUA_HOOK_FIRST; + } + else if (!strcasecmp(when, "late")) { + apr_hook_when = AP_LUA_HOOK_LAST; + } + else { + return "Third argument must be 'early' or 'late'"; + } + } + + return register_named_file_function_hook("access_checker", cmd, _cfg, + file, function, apr_hook_when); +} +static const char *register_access_checker_block(cmd_parms *cmd, void *_cfg, + const char *line) +{ + + return register_named_block_function_hook("access_checker", cmd, _cfg, + line); +} + +static const char *register_auth_checker_hook(cmd_parms *cmd, void *_cfg, + const char *file, + const char *function, + const char *when) +{ + int apr_hook_when = APR_HOOK_MIDDLE; + + if (when) { + if (!strcasecmp(when, "early")) { + apr_hook_when = AP_LUA_HOOK_FIRST; + } + else if (!strcasecmp(when, "late")) { + apr_hook_when = AP_LUA_HOOK_LAST; + } + else { + return "Third argument must be 'early' or 'late'"; + } + } + + return register_named_file_function_hook("auth_checker", cmd, _cfg, file, + function, apr_hook_when); +} +static const char *register_auth_checker_block(cmd_parms *cmd, void *_cfg, + const char *line) +{ + return register_named_block_function_hook("auth_checker", cmd, _cfg, + line); +} + +static const char *register_insert_filter_hook(cmd_parms *cmd, void *_cfg, + const char *file, + const char *function) +{ + return "LuaHookInsertFilter not yet implemented"; +} + +static const char *register_quick_hook(cmd_parms *cmd, void *_cfg, + const char *file, const char *function) +{ + const char *err = ap_check_cmd_context(cmd, NOT_IN_DIRECTORY|NOT_IN_FILES| + NOT_IN_HTACCESS); + if (err) { + return err; + } + return register_named_file_function_hook("quick", cmd, _cfg, file, + function, APR_HOOK_MIDDLE); +} +static const char *register_map_handler(cmd_parms *cmd, void *_cfg, + const char* match, const char *file, const char *function) +{ + const char *err = ap_check_cmd_context(cmd, NOT_IN_DIRECTORY|NOT_IN_FILES| + NOT_IN_HTACCESS); + if (err) { + return err; + } + if (!function) function = "handle"; + return register_mapped_file_function_hook(match, cmd, _cfg, file, + function); +} +static const char *register_output_filter(cmd_parms *cmd, void *_cfg, + const char* filter, const char *file, const char *function) +{ + const char *err = ap_check_cmd_context(cmd, NOT_IN_DIRECTORY|NOT_IN_FILES| + NOT_IN_HTACCESS); + if (err) { + return err; + } + if (!function) function = "handle"; + return register_filter_function_hook(filter, cmd, _cfg, file, + function, AP_LUA_FILTER_OUTPUT); +} +static const char *register_input_filter(cmd_parms *cmd, void *_cfg, + const char* filter, const char *file, const char *function) +{ + const char *err = ap_check_cmd_context(cmd, NOT_IN_DIRECTORY|NOT_IN_FILES| + NOT_IN_HTACCESS); + if (err) { + return err; + } + if (!function) function = "handle"; + return register_filter_function_hook(filter, cmd, _cfg, file, + function, AP_LUA_FILTER_INPUT); +} +static const char *register_quick_block(cmd_parms *cmd, void *_cfg, + const char *line) +{ + return register_named_block_function_hook("quick", cmd, _cfg, + line); +} + + + +static const char *register_package_helper(cmd_parms *cmd, + const char *arg, + apr_array_header_t *dir_array) +{ + apr_status_t rv; + + ap_lua_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) { + return apr_psprintf(cmd->pool, + "Unable to build full path to file, %s", arg); + } + + *(const char **) apr_array_push(dir_array) = fixed_filename; + return NULL; +} + + +/** + * Called for config directive which looks like + * LuaPackagePath /lua/package/path/mapped/thing/like/this/?.lua + */ +static const char *register_package_dir(cmd_parms *cmd, void *_cfg, + const char *arg) +{ + ap_lua_dir_cfg *cfg = (ap_lua_dir_cfg *) _cfg; + + return register_package_helper(cmd, arg, cfg->package_paths); +} + +/** + * Called for config directive which looks like + * LuaPackageCPath /lua/package/path/mapped/thing/like/this/?.so + */ +static const char *register_package_cdir(cmd_parms *cmd, + void *_cfg, + const char *arg) +{ + ap_lua_dir_cfg *cfg = (ap_lua_dir_cfg *) _cfg; + + return register_package_helper(cmd, arg, cfg->package_cpaths); +} + +static const char *register_lua_inherit(cmd_parms *cmd, + void *_cfg, + const char *arg) +{ + ap_lua_dir_cfg *cfg = (ap_lua_dir_cfg *) _cfg; + + if (strcasecmp("none", arg) == 0) { + cfg->inherit = AP_LUA_INHERIT_NONE; + } + else if (strcasecmp("parent-first", arg) == 0) { + cfg->inherit = AP_LUA_INHERIT_PARENT_FIRST; + } + else if (strcasecmp("parent-last", arg) == 0) { + cfg->inherit = AP_LUA_INHERIT_PARENT_LAST; + } + else { + return apr_psprintf(cmd->pool, + "LuaInherit type of '%s' not recognized, valid " + "options are 'none', 'parent-first', and 'parent-last'", + arg); + } + return NULL; +} +static const char *register_lua_codecache(cmd_parms *cmd, + void *_cfg, + const char *arg) +{ + ap_lua_dir_cfg *cfg = (ap_lua_dir_cfg *) _cfg; + + if (strcasecmp("never", arg) == 0) { + cfg->codecache = AP_LUA_CACHE_NEVER; + } + else if (strcasecmp("stat", arg) == 0) { + cfg->codecache = AP_LUA_CACHE_STAT; + } + else if (strcasecmp("forever", arg) == 0) { + cfg->codecache = AP_LUA_CACHE_FOREVER; + } + else { + return apr_psprintf(cmd->pool, + "LuaCodeCache type of '%s' not recognized, valid " + "options are 'never', 'stat', and 'forever'", + arg); + } + return NULL; +} +static const char *register_lua_scope(cmd_parms *cmd, + void *_cfg, + const char *scope, + const char *min, + const char *max) +{ + ap_lua_dir_cfg *cfg = (ap_lua_dir_cfg *) _cfg; + if (strcmp("once", scope) == 0) { + cfg->vm_scope = AP_LUA_SCOPE_ONCE; + } + else if (strcmp("request", scope) == 0) { + cfg->vm_scope = AP_LUA_SCOPE_REQUEST; + } + else if (strcmp("conn", scope) == 0) { + cfg->vm_scope = AP_LUA_SCOPE_CONN; + } + else if (strcmp("thread", scope) == 0) { +#if !APR_HAS_THREADS + return apr_psprintf(cmd->pool, + "Scope type of '%s' cannot be used because this " + "server does not have threading support " + "(APR_HAS_THREADS)" + scope); +#endif + cfg->vm_scope = AP_LUA_SCOPE_THREAD; + } + else if (strcmp("server", scope) == 0) { + unsigned int vmin, vmax; +#if !APR_HAS_THREADS + return apr_psprintf(cmd->pool, + "Scope type of '%s' cannot be used because this " + "server does not have threading support " + "(APR_HAS_THREADS)" + scope); +#endif + cfg->vm_scope = AP_LUA_SCOPE_SERVER; + vmin = min ? atoi(min) : 1; + vmax = max ? atoi(max) : 1; + if (vmin == 0) { + vmin = 1; + } + if (vmax < vmin) { + vmax = vmin; + } + cfg->vm_min = vmin; + cfg->vm_max = vmax; + } + else { + return apr_psprintf(cmd->pool, + "Invalid value for LuaScope, '%s', acceptable " + "values are: 'once', 'request', 'conn'" +#if APR_HAS_THREADS + ", 'thread', 'server'" +#endif + ,scope); + } + + return NULL; +} + + + +static const char *register_lua_root(cmd_parms *cmd, void *_cfg, + const char *root) +{ + /* ap_lua_dir_cfg* cfg = (ap_lua_dir_cfg*)_cfg; */ + ap_lua_server_cfg *cfg = ap_get_module_config(cmd->server->module_config, + &lua_module); + + cfg->root_path = root; + return NULL; +} + +const char *ap_lua_ssl_val(apr_pool_t *p, server_rec *s, conn_rec *c, + request_rec *r, const char *var) +{ + if (lua_ssl_val) { + return (const char *)lua_ssl_val(p, s, c, r, (char *)var); + } + return NULL; +} + +int ap_lua_ssl_is_https(conn_rec *c) +{ + return lua_ssl_is_https ? lua_ssl_is_https(c) : 0; +} + +/*******************************/ + +static const char *lua_authz_parse(cmd_parms *cmd, const char *require_line, + const void **parsed_require_line) +{ + const char *provider_name; + lua_authz_provider_spec *spec; + lua_authz_provider_func *func = apr_pcalloc(cmd->pool, sizeof(lua_authz_provider_func)); + + apr_pool_userdata_get((void**)&provider_name, AUTHZ_PROVIDER_NAME_NOTE, + cmd->temp_pool); + ap_assert(provider_name != NULL); + + spec = apr_hash_get(lua_authz_providers, provider_name, APR_HASH_KEY_STRING); + ap_assert(spec != NULL); + func->spec = spec; + + if (require_line && *require_line) { + const char *arg; + func->args = apr_array_make(cmd->pool, 2, sizeof(const char *)); + while ((arg = ap_getword_conf(cmd->pool, &require_line)) && *arg) { + APR_ARRAY_PUSH(func->args, const char *) = arg; + } + } + + *parsed_require_line = func; + return NULL; +} + +static authz_status lua_authz_check(request_rec *r, const char *require_line, + const void *parsed_require_line) +{ + apr_pool_t *pool; + ap_lua_vm_spec *spec; + lua_State *L; + 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 lua_authz_provider_func *prov_func = parsed_require_line; + const lua_authz_provider_spec *prov_spec = prov_func->spec; + int result; + int nargs = 0; + + spec = create_vm_spec(&pool, r, cfg, server_cfg, prov_spec->file_name, + NULL, 0, prov_spec->function_name, "authz provider"); + + L = ap_lua_get_lua_state(pool, spec, r); + if (L == NULL) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(02314) + "Unable to compile VM for authz provider %s", prov_spec->name); + return AUTHZ_GENERAL_ERROR; + } + lua_getglobal(L, prov_spec->function_name); + if (!lua_isfunction(L, -1)) { + ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, APLOGNO(02319) + "Unable to find entry function '%s' in %s (not a valid function)", + prov_spec->function_name, prov_spec->file_name); + ap_lua_release_state(L, spec, r); + return AUTHZ_GENERAL_ERROR; + } + ap_lua_run_lua_request(L, r); + if (prov_func->args) { + int i; + if (!lua_checkstack(L, prov_func->args->nelts)) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(02315) + "Error: authz provider %s: too many arguments", prov_spec->name); + ap_lua_release_state(L, spec, r); + return AUTHZ_GENERAL_ERROR; + } + for (i = 0; i < prov_func->args->nelts; i++) { + const char *arg = APR_ARRAY_IDX(prov_func->args, i, const char *); + lua_pushstring(L, arg); + } + nargs = prov_func->args->nelts; + } + if (lua_pcall(L, 1 + nargs, 1, 0)) { + const char *err = lua_tostring(L, -1); + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(02316) + "Error executing authz provider %s: %s", prov_spec->name, err); + ap_lua_release_state(L, spec, r); + return AUTHZ_GENERAL_ERROR; + } + if (!lua_isnumber(L, -1)) { + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(02317) + "Error: authz provider %s did not return integer", prov_spec->name); + ap_lua_release_state(L, spec, r); + return AUTHZ_GENERAL_ERROR; + } + result = lua_tointeger(L, -1); + ap_lua_release_state(L, spec, r); + switch (result) { + case AUTHZ_DENIED: + case AUTHZ_GRANTED: + case AUTHZ_NEUTRAL: + case AUTHZ_GENERAL_ERROR: + case AUTHZ_DENIED_NO_USER: + return result; + default: + ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(02318) + "Error: authz provider %s: invalid return value %d", + prov_spec->name, result); + } + return AUTHZ_GENERAL_ERROR; +} + +static const authz_provider lua_authz_provider = +{ + &lua_authz_check, + &lua_authz_parse, +}; + +static const char *register_authz_provider(cmd_parms *cmd, void *_cfg, + const char *name, const char *file, + const char *function) +{ + lua_authz_provider_spec *spec; + const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY); + if (err) + return err; + + spec = apr_pcalloc(cmd->pool, sizeof(*spec)); + spec->name = name; + spec->file_name = file; + spec->function_name = function; + + apr_hash_set(lua_authz_providers, name, APR_HASH_KEY_STRING, spec); + ap_register_auth_provider(cmd->pool, AUTHZ_PROVIDER_GROUP, name, + AUTHZ_PROVIDER_VERSION, + &lua_authz_provider, + AP_AUTH_INTERNAL_PER_CONF); + return NULL; +} + + +command_rec lua_commands[] = { + + AP_INIT_TAKE1("LuaRoot", register_lua_root, NULL, OR_ALL, + "Specify the base path for resolving relative paths for mod_lua directives"), + + AP_INIT_TAKE1("LuaPackagePath", register_package_dir, NULL, OR_ALL, + "Add a directory to lua's package.path"), + + AP_INIT_TAKE1("LuaPackageCPath", register_package_cdir, NULL, OR_ALL, + "Add a directory to lua's package.cpath"), + + AP_INIT_TAKE3("LuaAuthzProvider", register_authz_provider, NULL, RSRC_CONF|EXEC_ON_READ, + "Provide an authorization provider"), + + AP_INIT_TAKE23("LuaHookTranslateName", register_translate_name_hook, NULL, + OR_ALL, + "Provide a hook for the translate name phase of request processing"), + + AP_INIT_RAW_ARGS("<LuaHookTranslateName", register_translate_name_block, + NULL, + EXEC_ON_READ | OR_ALL, + "Provide a hook for the translate name phase of request processing"), + + AP_INIT_TAKE2("LuaHookFixups", register_fixups_hook, NULL, OR_ALL, + "Provide a hook for the fixups phase of request processing"), + AP_INIT_RAW_ARGS("<LuaHookFixups", register_fixups_block, NULL, + EXEC_ON_READ | OR_ALL, + "Provide a inline hook for the fixups phase of request processing"), + + /* todo: test */ + AP_INIT_TAKE2("LuaHookMapToStorage", register_map_to_storage_hook, NULL, + OR_ALL, + "Provide a hook for the map_to_storage phase of request processing"), + AP_INIT_RAW_ARGS("<LuaHookMapToStorage", register_map_to_storage_block, + NULL, + EXEC_ON_READ | OR_ALL, + "Provide a hook for the map_to_storage phase of request processing"), + + /* todo: test */ + AP_INIT_TAKE23("LuaHookCheckUserID", register_check_user_id_hook, NULL, + OR_ALL, + "Provide a hook for the check_user_id phase of request processing"), + AP_INIT_RAW_ARGS("<LuaHookCheckUserID", register_check_user_id_block, + NULL, + EXEC_ON_READ | OR_ALL, + "Provide a hook for the check_user_id phase of request processing"), + + /* todo: test */ + AP_INIT_TAKE2("LuaHookTypeChecker", register_type_checker_hook, NULL, + OR_ALL, + "Provide a hook for the type_checker phase of request processing"), + AP_INIT_RAW_ARGS("<LuaHookTypeChecker", register_type_checker_block, NULL, + EXEC_ON_READ | OR_ALL, + "Provide a hook for the type_checker phase of request processing"), + + /* todo: test */ + AP_INIT_TAKE23("LuaHookAccessChecker", register_access_checker_hook, NULL, + OR_ALL, + "Provide a hook for the access_checker phase of request processing"), + AP_INIT_RAW_ARGS("<LuaHookAccessChecker", register_access_checker_block, + NULL, + EXEC_ON_READ | OR_ALL, + "Provide a hook for the access_checker phase of request processing"), + + /* todo: test */ + AP_INIT_TAKE23("LuaHookAuthChecker", register_auth_checker_hook, NULL, + OR_ALL, + "Provide a hook for the auth_checker phase of request processing"), + AP_INIT_RAW_ARGS("<LuaHookAuthChecker", register_auth_checker_block, NULL, + EXEC_ON_READ | OR_ALL, + "Provide a hook for the auth_checker phase of request processing"), + + /* todo: test */ + AP_INIT_TAKE2("LuaHookInsertFilter", register_insert_filter_hook, NULL, + OR_ALL, + "Provide a hook for the insert_filter phase of request processing"), + + AP_INIT_TAKE2("LuaHookLog", register_log_transaction_hook, NULL, + OR_ALL, + "Provide a hook for the logging phase of request processing"), + + AP_INIT_TAKE123("LuaScope", register_lua_scope, NULL, OR_ALL, + "One of once, request, conn, server -- default is once"), + + AP_INIT_TAKE1("LuaInherit", register_lua_inherit, NULL, OR_ALL, + "Controls how Lua scripts in parent contexts are merged with the current " + " context: none|parent-last|parent-first (default: parent-first) "), + + AP_INIT_TAKE1("LuaCodeCache", register_lua_codecache, NULL, OR_ALL, + "Controls the behavior of the in-memory code cache " + " context: stat|forever|never (default: stat) "), + + AP_INIT_TAKE2("LuaQuickHandler", register_quick_hook, NULL, OR_ALL, + "Provide a hook for the quick handler of request processing"), + AP_INIT_RAW_ARGS("<LuaQuickHandler", register_quick_block, NULL, + EXEC_ON_READ | OR_ALL, + "Provide a hook for the quick handler of request processing"), + AP_INIT_RAW_ARGS("Lua_____ByteCodeHack", hack_section_handler, NULL, + OR_ALL, + "(internal) Byte code handler"), + AP_INIT_TAKE23("LuaMapHandler", register_map_handler, NULL, OR_ALL, + "Maps a path to a lua handler"), + AP_INIT_TAKE3("LuaOutputFilter", register_output_filter, NULL, OR_ALL, + "Registers a Lua function as an output filter"), + AP_INIT_TAKE3("LuaInputFilter", register_input_filter, NULL, OR_ALL, + "Registers a Lua function as an input filter"), + {NULL} +}; + + +static void *create_dir_config(apr_pool_t *p, char *dir) +{ + ap_lua_dir_cfg *cfg = apr_pcalloc(p, sizeof(ap_lua_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(ap_lua_mapped_handler_spec *)); + cfg->mapped_filters = + apr_array_make(p, 1, sizeof(ap_lua_filter_handler_spec *)); + cfg->pool = p; + cfg->hooks = apr_hash_make(p); + cfg->dir = apr_pstrdup(p, dir); + cfg->vm_scope = AP_LUA_SCOPE_UNSET; + cfg->codecache = AP_LUA_CACHE_UNSET; + cfg->vm_min = 0; + cfg->vm_max = 0; + cfg->inherit = AP_LUA_INHERIT_UNSET; + + return cfg; +} + +static int create_request_config(request_rec *r) +{ + ap_lua_request_cfg *cfg = apr_palloc(r->pool, sizeof(ap_lua_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); + return OK; +} + +static void *create_server_config(apr_pool_t *p, server_rec *s) +{ + + ap_lua_server_cfg *cfg = apr_pcalloc(p, sizeof(ap_lua_server_cfg)); + cfg->root_path = NULL; + + return cfg; +} + +static int lua_request_hook(lua_State *L, request_rec *r) +{ + ap_lua_push_request(L, r); + return OK; +} + +static int lua_pre_config(apr_pool_t *pconf, apr_pool_t *plog, + apr_pool_t *ptemp) +{ + ap_mutex_register(pconf, "lua-ivm-shm", NULL, APR_LOCK_DEFAULT, 0); + return OK; +} + +static int lua_post_config(apr_pool_t *pconf, apr_pool_t *plog, + apr_pool_t *ptemp, server_rec *s) +{ + apr_pool_t **pool; + apr_status_t rs; + + lua_ssl_val = APR_RETRIEVE_OPTIONAL_FN(ssl_var_lookup); + lua_ssl_is_https = APR_RETRIEVE_OPTIONAL_FN(ssl_is_https); + + if (ap_state_query(AP_SQ_MAIN_STATE) == AP_SQ_MS_CREATE_PRE_CONFIG) + return OK; + + /* Create ivm mutex */ + rs = ap_global_mutex_create(&lua_ivm_mutex, NULL, "lua-ivm-shm", NULL, + s, pconf, 0); + if (APR_SUCCESS != rs) { + return HTTP_INTERNAL_SERVER_ERROR; + } + + /* Create shared memory space, anonymous first if possible. */ + rs = apr_shm_create(&lua_ivm_shm, sizeof pool, NULL, pconf); + if (APR_STATUS_IS_ENOTIMPL(rs)) { + /* Fall back to filename-based; nuke any left-over first. */ + lua_ivm_shmfile = ap_runtime_dir_relative(pconf, DEFAULT_LUA_SHMFILE); + + apr_shm_remove(lua_ivm_shmfile, pconf); + + rs = apr_shm_create(&lua_ivm_shm, sizeof pool, lua_ivm_shmfile, pconf); + } + if (rs != APR_SUCCESS) { + ap_log_error(APLOG_MARK, APLOG_ERR, rs, s, APLOGNO(02665) + "mod_lua: Failed to create shared memory segment on file %s", + lua_ivm_shmfile ? lua_ivm_shmfile : "(anonymous)"); + return HTTP_INTERNAL_SERVER_ERROR; + } + pool = (apr_pool_t **)apr_shm_baseaddr_get(lua_ivm_shm); + apr_pool_create(pool, pconf); + apr_pool_cleanup_register(pconf, NULL, shm_cleanup_wrapper, + apr_pool_cleanup_null); + return OK; +} +static void *overlay_hook_specs(apr_pool_t *p, + const void *key, + apr_ssize_t klen, + const void *overlay_val, + const void *base_val, + const void *data) +{ + const apr_array_header_t *overlay_info = (const apr_array_header_t*)overlay_val; + const apr_array_header_t *base_info = (const apr_array_header_t*)base_val; + return apr_array_append(p, base_info, overlay_info); +} + +static void *merge_dir_config(apr_pool_t *p, void *basev, void *overridesv) +{ + ap_lua_dir_cfg *a, *base, *overrides; + + a = (ap_lua_dir_cfg *)apr_pcalloc(p, sizeof(ap_lua_dir_cfg)); + base = (ap_lua_dir_cfg*)basev; + overrides = (ap_lua_dir_cfg*)overridesv; + + a->pool = overrides->pool; + a->dir = apr_pstrdup(p, overrides->dir); + + a->vm_scope = (overrides->vm_scope == AP_LUA_SCOPE_UNSET) ? base->vm_scope: overrides->vm_scope; + a->inherit = (overrides->inherit == AP_LUA_INHERIT_UNSET) ? base->inherit : overrides->inherit; + a->codecache = (overrides->codecache == AP_LUA_CACHE_UNSET) ? base->codecache : overrides->codecache; + + a->vm_min = (overrides->vm_min == 0) ? base->vm_min : overrides->vm_min; + a->vm_max = (overrides->vm_max == 0) ? base->vm_max : overrides->vm_max; + + if (a->inherit == AP_LUA_INHERIT_UNSET || a->inherit == AP_LUA_INHERIT_PARENT_FIRST) { + a->package_paths = apr_array_append(p, base->package_paths, overrides->package_paths); + a->package_cpaths = apr_array_append(p, base->package_cpaths, overrides->package_cpaths); + a->mapped_handlers = apr_array_append(p, base->mapped_handlers, overrides->mapped_handlers); + a->mapped_filters = apr_array_append(p, base->mapped_filters, overrides->mapped_filters); + a->hooks = apr_hash_merge(p, overrides->hooks, base->hooks, overlay_hook_specs, NULL); + } + else if (a->inherit == AP_LUA_INHERIT_PARENT_LAST) { + a->package_paths = apr_array_append(p, overrides->package_paths, base->package_paths); + a->package_cpaths = apr_array_append(p, overrides->package_cpaths, base->package_cpaths); + a->mapped_handlers = apr_array_append(p, overrides->mapped_handlers, base->mapped_handlers); + a->mapped_filters = apr_array_append(p, overrides->mapped_filters, base->mapped_filters); + a->hooks = apr_hash_merge(p, base->hooks, overrides->hooks, overlay_hook_specs, NULL); + } + else { + a->package_paths = overrides->package_paths; + a->package_cpaths = overrides->package_cpaths; + a->mapped_handlers= overrides->mapped_handlers; + a->mapped_filters= overrides->mapped_filters; + a->hooks= overrides->hooks; + } + + return a; +} + +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(lua_translate_name_harness_first, NULL, NULL, + AP_LUA_HOOK_FIRST); + ap_hook_translate_name(lua_translate_name_harness, NULL, NULL, + APR_HOOK_MIDDLE); + ap_hook_translate_name(lua_translate_name_harness_last, NULL, NULL, + AP_LUA_HOOK_LAST); + + 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); + +/* XXX: Does not work :( + * ap_hook_check_user_id(lua_check_user_id_harness_first, NULL, NULL, + AP_LUA_HOOK_FIRST); + */ + ap_hook_check_user_id(lua_check_user_id_harness, NULL, NULL, + APR_HOOK_MIDDLE); +/* XXX: Does not work :( + * ap_hook_check_user_id(lua_check_user_id_harness_last, NULL, NULL, + AP_LUA_HOOK_LAST); +*/ + ap_hook_type_checker(lua_type_checker_harness, NULL, NULL, + APR_HOOK_MIDDLE); + + ap_hook_access_checker(lua_access_checker_harness_first, NULL, NULL, + AP_LUA_HOOK_FIRST); + ap_hook_access_checker(lua_access_checker_harness, NULL, NULL, + APR_HOOK_MIDDLE); + ap_hook_access_checker(lua_access_checker_harness_last, NULL, NULL, + AP_LUA_HOOK_LAST); + ap_hook_auth_checker(lua_auth_checker_harness_first, NULL, NULL, + AP_LUA_HOOK_FIRST); + ap_hook_auth_checker(lua_auth_checker_harness, NULL, NULL, + APR_HOOK_MIDDLE); + ap_hook_auth_checker(lua_auth_checker_harness_last, NULL, NULL, + AP_LUA_HOOK_LAST); + + 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_post_config(lua_post_config, NULL, NULL, APR_HOOK_MIDDLE); + ap_hook_pre_config(lua_pre_config, NULL, NULL, APR_HOOK_MIDDLE); + + APR_OPTIONAL_HOOK(ap_lua, lua_open, lua_open_hook, NULL, NULL, + APR_HOOK_REALLY_FIRST); + + APR_OPTIONAL_HOOK(ap_lua, lua_request, lua_request_hook, NULL, NULL, + APR_HOOK_REALLY_FIRST); + ap_hook_handler(lua_map_handler, NULL, NULL, AP_LUA_HOOK_FIRST); + + /* Hook this right before FallbackResource kicks in */ + ap_hook_fixups(lua_map_handler_fixups, NULL, NULL, AP_LUA_HOOK_LAST-2); +#if APR_HAS_THREADS + ap_hook_child_init(ap_lua_init_mutex, NULL, NULL, APR_HOOK_MIDDLE); +#endif + /* providers */ + lua_authz_providers = apr_hash_make(p); + + /* Logging catcher */ + ap_hook_log_transaction(lua_log_transaction_harness,NULL,NULL, + APR_HOOK_FIRST); +} + +AP_DECLARE_MODULE(lua) = { + STANDARD20_MODULE_STUFF, + create_dir_config, /* create per-dir config structures */ + merge_dir_config, /* merge per-dir config structures */ + create_server_config, /* create per-server config structures */ + NULL, /* merge per-server config structures */ + lua_commands, /* table of config file commands */ + lua_register_hooks /* register hooks */ +}; diff --git a/modules/lua/mod_lua.dep b/modules/lua/mod_lua.dep new file mode 100644 index 0000000..126b7ce --- /dev/null +++ b/modules/lua/mod_lua.dep @@ -0,0 +1,418 @@ +# Microsoft Developer Studio Generated Dependency File, included by mod_lua.mak + +..\..\build\win32\httpd.rc : \ + "..\..\include\ap_release.h"\ + + +.\lua_apr.c : \ + "..\..\include\ap_config.h"\ + "..\..\include\ap_config_layout.h"\ + "..\..\include\ap_expr.h"\ + "..\..\include\ap_hooks.h"\ + "..\..\include\ap_mmn.h"\ + "..\..\include\ap_mpm.h"\ + "..\..\include\ap_regex.h"\ + "..\..\include\ap_release.h"\ + "..\..\include\apache_noprobes.h"\ + "..\..\include\http_config.h"\ + "..\..\include\http_core.h"\ + "..\..\include\http_log.h"\ + "..\..\include\http_main.h"\ + "..\..\include\http_protocol.h"\ + "..\..\include\http_request.h"\ + "..\..\include\httpd.h"\ + "..\..\include\os.h"\ + "..\..\include\scoreboard.h"\ + "..\..\include\util_cfgtree.h"\ + "..\..\include\util_filter.h"\ + "..\..\include\util_varbuf.h"\ + "..\..\srclib\apr-util\include\apr_base64.h"\ + "..\..\srclib\apr-util\include\apr_buckets.h"\ + "..\..\srclib\apr-util\include\apr_hooks.h"\ + "..\..\srclib\apr-util\include\apr_md5.h"\ + "..\..\srclib\apr-util\include\apr_optional.h"\ + "..\..\srclib\apr-util\include\apr_optional_hooks.h"\ + "..\..\srclib\apr-util\include\apr_reslist.h"\ + "..\..\srclib\apr-util\include\apr_sha1.h"\ + "..\..\srclib\apr-util\include\apr_uri.h"\ + "..\..\srclib\apr-util\include\apr_xlate.h"\ + "..\..\srclib\apr-util\include\apu.h"\ + "..\..\srclib\apr\include\apr.h"\ + "..\..\srclib\apr\include\apr_allocator.h"\ + "..\..\srclib\apr\include\apr_dso.h"\ + "..\..\srclib\apr\include\apr_errno.h"\ + "..\..\srclib\apr\include\apr_file_info.h"\ + "..\..\srclib\apr\include\apr_file_io.h"\ + "..\..\srclib\apr\include\apr_general.h"\ + "..\..\srclib\apr\include\apr_global_mutex.h"\ + "..\..\srclib\apr\include\apr_hash.h"\ + "..\..\srclib\apr\include\apr_inherit.h"\ + "..\..\srclib\apr\include\apr_mmap.h"\ + "..\..\srclib\apr\include\apr_network_io.h"\ + "..\..\srclib\apr\include\apr_poll.h"\ + "..\..\srclib\apr\include\apr_pools.h"\ + "..\..\srclib\apr\include\apr_portable.h"\ + "..\..\srclib\apr\include\apr_proc_mutex.h"\ + "..\..\srclib\apr\include\apr_ring.h"\ + "..\..\srclib\apr\include\apr_shm.h"\ + "..\..\srclib\apr\include\apr_strings.h"\ + "..\..\srclib\apr\include\apr_tables.h"\ + "..\..\srclib\apr\include\apr_thread_mutex.h"\ + "..\..\srclib\apr\include\apr_thread_proc.h"\ + "..\..\srclib\apr\include\apr_thread_rwlock.h"\ + "..\..\srclib\apr\include\apr_time.h"\ + "..\..\srclib\apr\include\apr_user.h"\ + "..\..\srclib\apr\include\apr_want.h"\ + ".\lua_apr.h"\ + ".\lua_request.h"\ + ".\lua_vmprep.h"\ + ".\mod_lua.h"\ + + +.\lua_config.c : \ + "..\..\include\ap_config.h"\ + "..\..\include\ap_config_layout.h"\ + "..\..\include\ap_expr.h"\ + "..\..\include\ap_hooks.h"\ + "..\..\include\ap_mmn.h"\ + "..\..\include\ap_regex.h"\ + "..\..\include\ap_release.h"\ + "..\..\include\apache_noprobes.h"\ + "..\..\include\http_config.h"\ + "..\..\include\http_core.h"\ + "..\..\include\http_log.h"\ + "..\..\include\http_protocol.h"\ + "..\..\include\http_request.h"\ + "..\..\include\httpd.h"\ + "..\..\include\os.h"\ + "..\..\include\util_cfgtree.h"\ + "..\..\include\util_filter.h"\ + "..\..\include\util_varbuf.h"\ + "..\..\srclib\apr-util\include\apr_buckets.h"\ + "..\..\srclib\apr-util\include\apr_hooks.h"\ + "..\..\srclib\apr-util\include\apr_optional.h"\ + "..\..\srclib\apr-util\include\apr_optional_hooks.h"\ + "..\..\srclib\apr-util\include\apr_reslist.h"\ + "..\..\srclib\apr-util\include\apr_uri.h"\ + "..\..\srclib\apr-util\include\apu.h"\ + "..\..\srclib\apr\include\apr.h"\ + "..\..\srclib\apr\include\apr_allocator.h"\ + "..\..\srclib\apr\include\apr_dso.h"\ + "..\..\srclib\apr\include\apr_errno.h"\ + "..\..\srclib\apr\include\apr_file_info.h"\ + "..\..\srclib\apr\include\apr_file_io.h"\ + "..\..\srclib\apr\include\apr_general.h"\ + "..\..\srclib\apr\include\apr_global_mutex.h"\ + "..\..\srclib\apr\include\apr_hash.h"\ + "..\..\srclib\apr\include\apr_inherit.h"\ + "..\..\srclib\apr\include\apr_mmap.h"\ + "..\..\srclib\apr\include\apr_network_io.h"\ + "..\..\srclib\apr\include\apr_poll.h"\ + "..\..\srclib\apr\include\apr_pools.h"\ + "..\..\srclib\apr\include\apr_portable.h"\ + "..\..\srclib\apr\include\apr_proc_mutex.h"\ + "..\..\srclib\apr\include\apr_ring.h"\ + "..\..\srclib\apr\include\apr_shm.h"\ + "..\..\srclib\apr\include\apr_strings.h"\ + "..\..\srclib\apr\include\apr_tables.h"\ + "..\..\srclib\apr\include\apr_thread_mutex.h"\ + "..\..\srclib\apr\include\apr_thread_proc.h"\ + "..\..\srclib\apr\include\apr_thread_rwlock.h"\ + "..\..\srclib\apr\include\apr_time.h"\ + "..\..\srclib\apr\include\apr_user.h"\ + "..\..\srclib\apr\include\apr_want.h"\ + ".\lua_config.h"\ + ".\lua_request.h"\ + ".\lua_vmprep.h"\ + ".\mod_lua.h"\ + + +.\lua_dbd.c : \ + "..\..\include\ap_config.h"\ + "..\..\include\ap_config_layout.h"\ + "..\..\include\ap_expr.h"\ + "..\..\include\ap_hooks.h"\ + "..\..\include\ap_mmn.h"\ + "..\..\include\ap_regex.h"\ + "..\..\include\ap_release.h"\ + "..\..\include\apache_noprobes.h"\ + "..\..\include\http_config.h"\ + "..\..\include\http_core.h"\ + "..\..\include\http_log.h"\ + "..\..\include\http_protocol.h"\ + "..\..\include\http_request.h"\ + "..\..\include\httpd.h"\ + "..\..\include\os.h"\ + "..\..\include\util_cfgtree.h"\ + "..\..\include\util_filter.h"\ + "..\..\include\util_varbuf.h"\ + "..\..\srclib\apr-util\include\apr_buckets.h"\ + "..\..\srclib\apr-util\include\apr_dbd.h"\ + "..\..\srclib\apr-util\include\apr_hooks.h"\ + "..\..\srclib\apr-util\include\apr_optional.h"\ + "..\..\srclib\apr-util\include\apr_optional_hooks.h"\ + "..\..\srclib\apr-util\include\apr_reslist.h"\ + "..\..\srclib\apr-util\include\apr_uri.h"\ + "..\..\srclib\apr-util\include\apu.h"\ + "..\..\srclib\apr\include\apr.h"\ + "..\..\srclib\apr\include\apr_allocator.h"\ + "..\..\srclib\apr\include\apr_dso.h"\ + "..\..\srclib\apr\include\apr_errno.h"\ + "..\..\srclib\apr\include\apr_file_info.h"\ + "..\..\srclib\apr\include\apr_file_io.h"\ + "..\..\srclib\apr\include\apr_general.h"\ + "..\..\srclib\apr\include\apr_global_mutex.h"\ + "..\..\srclib\apr\include\apr_hash.h"\ + "..\..\srclib\apr\include\apr_inherit.h"\ + "..\..\srclib\apr\include\apr_mmap.h"\ + "..\..\srclib\apr\include\apr_network_io.h"\ + "..\..\srclib\apr\include\apr_poll.h"\ + "..\..\srclib\apr\include\apr_pools.h"\ + "..\..\srclib\apr\include\apr_portable.h"\ + "..\..\srclib\apr\include\apr_proc_mutex.h"\ + "..\..\srclib\apr\include\apr_ring.h"\ + "..\..\srclib\apr\include\apr_shm.h"\ + "..\..\srclib\apr\include\apr_strings.h"\ + "..\..\srclib\apr\include\apr_tables.h"\ + "..\..\srclib\apr\include\apr_thread_mutex.h"\ + "..\..\srclib\apr\include\apr_thread_proc.h"\ + "..\..\srclib\apr\include\apr_thread_rwlock.h"\ + "..\..\srclib\apr\include\apr_time.h"\ + "..\..\srclib\apr\include\apr_user.h"\ + "..\..\srclib\apr\include\apr_want.h"\ + "..\database\mod_dbd.h"\ + ".\lua_dbd.h"\ + ".\lua_request.h"\ + ".\lua_vmprep.h"\ + ".\mod_lua.h"\ + + +.\lua_passwd.c : \ + "..\..\srclib\apr-util\include\apr_md5.h"\ + "..\..\srclib\apr-util\include\apr_sha1.h"\ + "..\..\srclib\apr-util\include\apr_xlate.h"\ + "..\..\srclib\apr-util\include\apu.h"\ + "..\..\srclib\apr-util\include\apu_version.h"\ + "..\..\srclib\apr\include\apr.h"\ + "..\..\srclib\apr\include\apr_allocator.h"\ + "..\..\srclib\apr\include\apr_errno.h"\ + "..\..\srclib\apr\include\apr_file_info.h"\ + "..\..\srclib\apr\include\apr_file_io.h"\ + "..\..\srclib\apr\include\apr_general.h"\ + "..\..\srclib\apr\include\apr_inherit.h"\ + "..\..\srclib\apr\include\apr_lib.h"\ + "..\..\srclib\apr\include\apr_pools.h"\ + "..\..\srclib\apr\include\apr_strings.h"\ + "..\..\srclib\apr\include\apr_tables.h"\ + "..\..\srclib\apr\include\apr_thread_mutex.h"\ + "..\..\srclib\apr\include\apr_time.h"\ + "..\..\srclib\apr\include\apr_user.h"\ + "..\..\srclib\apr\include\apr_version.h"\ + "..\..\srclib\apr\include\apr_want.h"\ + ".\lua_passwd.h"\ + + +.\lua_request.c : \ + "..\..\include\ap_config.h"\ + "..\..\include\ap_config_layout.h"\ + "..\..\include\ap_expr.h"\ + "..\..\include\ap_hooks.h"\ + "..\..\include\ap_mmn.h"\ + "..\..\include\ap_mpm.h"\ + "..\..\include\ap_regex.h"\ + "..\..\include\ap_release.h"\ + "..\..\include\apache_noprobes.h"\ + "..\..\include\http_config.h"\ + "..\..\include\http_core.h"\ + "..\..\include\http_log.h"\ + "..\..\include\http_main.h"\ + "..\..\include\http_protocol.h"\ + "..\..\include\http_request.h"\ + "..\..\include\httpd.h"\ + "..\..\include\os.h"\ + "..\..\include\scoreboard.h"\ + "..\..\include\util_cfgtree.h"\ + "..\..\include\util_cookies.h"\ + "..\..\include\util_filter.h"\ + "..\..\include\util_md5.h"\ + "..\..\include\util_script.h"\ + "..\..\include\util_varbuf.h"\ + "..\..\srclib\apr-util\include\apr_base64.h"\ + "..\..\srclib\apr-util\include\apr_buckets.h"\ + "..\..\srclib\apr-util\include\apr_date.h"\ + "..\..\srclib\apr-util\include\apr_dbd.h"\ + "..\..\srclib\apr-util\include\apr_hooks.h"\ + "..\..\srclib\apr-util\include\apr_md5.h"\ + "..\..\srclib\apr-util\include\apr_optional.h"\ + "..\..\srclib\apr-util\include\apr_optional_hooks.h"\ + "..\..\srclib\apr-util\include\apr_reslist.h"\ + "..\..\srclib\apr-util\include\apr_sha1.h"\ + "..\..\srclib\apr-util\include\apr_uri.h"\ + "..\..\srclib\apr-util\include\apr_xlate.h"\ + "..\..\srclib\apr-util\include\apu.h"\ + "..\..\srclib\apr-util\include\apu_version.h"\ + "..\..\srclib\apr\include\apr.h"\ + "..\..\srclib\apr\include\apr_allocator.h"\ + "..\..\srclib\apr\include\apr_dso.h"\ + "..\..\srclib\apr\include\apr_errno.h"\ + "..\..\srclib\apr\include\apr_file_info.h"\ + "..\..\srclib\apr\include\apr_file_io.h"\ + "..\..\srclib\apr\include\apr_general.h"\ + "..\..\srclib\apr\include\apr_global_mutex.h"\ + "..\..\srclib\apr\include\apr_hash.h"\ + "..\..\srclib\apr\include\apr_inherit.h"\ + "..\..\srclib\apr\include\apr_lib.h"\ + "..\..\srclib\apr\include\apr_mmap.h"\ + "..\..\srclib\apr\include\apr_network_io.h"\ + "..\..\srclib\apr\include\apr_poll.h"\ + "..\..\srclib\apr\include\apr_pools.h"\ + "..\..\srclib\apr\include\apr_portable.h"\ + "..\..\srclib\apr\include\apr_proc_mutex.h"\ + "..\..\srclib\apr\include\apr_ring.h"\ + "..\..\srclib\apr\include\apr_shm.h"\ + "..\..\srclib\apr\include\apr_strings.h"\ + "..\..\srclib\apr\include\apr_tables.h"\ + "..\..\srclib\apr\include\apr_thread_mutex.h"\ + "..\..\srclib\apr\include\apr_thread_proc.h"\ + "..\..\srclib\apr\include\apr_thread_rwlock.h"\ + "..\..\srclib\apr\include\apr_time.h"\ + "..\..\srclib\apr\include\apr_user.h"\ + "..\..\srclib\apr\include\apr_version.h"\ + "..\..\srclib\apr\include\apr_want.h"\ + "..\database\mod_dbd.h"\ + ".\lua_apr.h"\ + ".\lua_dbd.h"\ + ".\lua_passwd.h"\ + ".\lua_request.h"\ + ".\lua_vmprep.h"\ + ".\mod_lua.h"\ + + +.\lua_vmprep.c : \ + "..\..\include\ap_config.h"\ + "..\..\include\ap_config_layout.h"\ + "..\..\include\ap_expr.h"\ + "..\..\include\ap_hooks.h"\ + "..\..\include\ap_mmn.h"\ + "..\..\include\ap_regex.h"\ + "..\..\include\ap_release.h"\ + "..\..\include\apache_noprobes.h"\ + "..\..\include\http_config.h"\ + "..\..\include\http_core.h"\ + "..\..\include\http_log.h"\ + "..\..\include\http_protocol.h"\ + "..\..\include\http_request.h"\ + "..\..\include\httpd.h"\ + "..\..\include\mod_auth.h"\ + "..\..\include\os.h"\ + "..\..\include\util_cfgtree.h"\ + "..\..\include\util_filter.h"\ + "..\..\include\util_varbuf.h"\ + "..\..\srclib\apr-util\include\apr_buckets.h"\ + "..\..\srclib\apr-util\include\apr_hooks.h"\ + "..\..\srclib\apr-util\include\apr_optional.h"\ + "..\..\srclib\apr-util\include\apr_optional_hooks.h"\ + "..\..\srclib\apr-util\include\apr_reslist.h"\ + "..\..\srclib\apr-util\include\apr_uri.h"\ + "..\..\srclib\apr-util\include\apr_uuid.h"\ + "..\..\srclib\apr-util\include\apu.h"\ + "..\..\srclib\apr\include\apr.h"\ + "..\..\srclib\apr\include\apr_allocator.h"\ + "..\..\srclib\apr\include\apr_dso.h"\ + "..\..\srclib\apr\include\apr_errno.h"\ + "..\..\srclib\apr\include\apr_file_info.h"\ + "..\..\srclib\apr\include\apr_file_io.h"\ + "..\..\srclib\apr\include\apr_general.h"\ + "..\..\srclib\apr\include\apr_global_mutex.h"\ + "..\..\srclib\apr\include\apr_hash.h"\ + "..\..\srclib\apr\include\apr_inherit.h"\ + "..\..\srclib\apr\include\apr_mmap.h"\ + "..\..\srclib\apr\include\apr_network_io.h"\ + "..\..\srclib\apr\include\apr_poll.h"\ + "..\..\srclib\apr\include\apr_pools.h"\ + "..\..\srclib\apr\include\apr_portable.h"\ + "..\..\srclib\apr\include\apr_proc_mutex.h"\ + "..\..\srclib\apr\include\apr_ring.h"\ + "..\..\srclib\apr\include\apr_shm.h"\ + "..\..\srclib\apr\include\apr_strings.h"\ + "..\..\srclib\apr\include\apr_tables.h"\ + "..\..\srclib\apr\include\apr_thread_mutex.h"\ + "..\..\srclib\apr\include\apr_thread_proc.h"\ + "..\..\srclib\apr\include\apr_thread_rwlock.h"\ + "..\..\srclib\apr\include\apr_time.h"\ + "..\..\srclib\apr\include\apr_user.h"\ + "..\..\srclib\apr\include\apr_want.h"\ + ".\lua_config.h"\ + ".\lua_request.h"\ + ".\lua_vmprep.h"\ + ".\mod_lua.h"\ + + +.\mod_lua.c : \ + "..\..\include\ap_config.h"\ + "..\..\include\ap_config_layout.h"\ + "..\..\include\ap_expr.h"\ + "..\..\include\ap_hooks.h"\ + "..\..\include\ap_mmn.h"\ + "..\..\include\ap_mpm.h"\ + "..\..\include\ap_regex.h"\ + "..\..\include\ap_release.h"\ + "..\..\include\apache_noprobes.h"\ + "..\..\include\http_config.h"\ + "..\..\include\http_core.h"\ + "..\..\include\http_log.h"\ + "..\..\include\http_main.h"\ + "..\..\include\http_protocol.h"\ + "..\..\include\http_request.h"\ + "..\..\include\httpd.h"\ + "..\..\include\mod_auth.h"\ + "..\..\include\os.h"\ + "..\..\include\scoreboard.h"\ + "..\..\include\util_cfgtree.h"\ + "..\..\include\util_filter.h"\ + "..\..\include\util_mutex.h"\ + "..\..\include\util_varbuf.h"\ + "..\..\srclib\apr-util\include\apr_base64.h"\ + "..\..\srclib\apr-util\include\apr_buckets.h"\ + "..\..\srclib\apr-util\include\apr_hooks.h"\ + "..\..\srclib\apr-util\include\apr_md5.h"\ + "..\..\srclib\apr-util\include\apr_optional.h"\ + "..\..\srclib\apr-util\include\apr_optional_hooks.h"\ + "..\..\srclib\apr-util\include\apr_reslist.h"\ + "..\..\srclib\apr-util\include\apr_sha1.h"\ + "..\..\srclib\apr-util\include\apr_uri.h"\ + "..\..\srclib\apr-util\include\apr_xlate.h"\ + "..\..\srclib\apr-util\include\apu.h"\ + "..\..\srclib\apr\include\apr.h"\ + "..\..\srclib\apr\include\apr_allocator.h"\ + "..\..\srclib\apr\include\apr_dso.h"\ + "..\..\srclib\apr\include\apr_errno.h"\ + "..\..\srclib\apr\include\apr_file_info.h"\ + "..\..\srclib\apr\include\apr_file_io.h"\ + "..\..\srclib\apr\include\apr_general.h"\ + "..\..\srclib\apr\include\apr_global_mutex.h"\ + "..\..\srclib\apr\include\apr_hash.h"\ + "..\..\srclib\apr\include\apr_inherit.h"\ + "..\..\srclib\apr\include\apr_mmap.h"\ + "..\..\srclib\apr\include\apr_network_io.h"\ + "..\..\srclib\apr\include\apr_poll.h"\ + "..\..\srclib\apr\include\apr_pools.h"\ + "..\..\srclib\apr\include\apr_portable.h"\ + "..\..\srclib\apr\include\apr_proc_mutex.h"\ + "..\..\srclib\apr\include\apr_ring.h"\ + "..\..\srclib\apr\include\apr_shm.h"\ + "..\..\srclib\apr\include\apr_strings.h"\ + "..\..\srclib\apr\include\apr_tables.h"\ + "..\..\srclib\apr\include\apr_thread_mutex.h"\ + "..\..\srclib\apr\include\apr_thread_proc.h"\ + "..\..\srclib\apr\include\apr_thread_rwlock.h"\ + "..\..\srclib\apr\include\apr_time.h"\ + "..\..\srclib\apr\include\apr_user.h"\ + "..\..\srclib\apr\include\apr_want.h"\ + "..\ssl\mod_ssl.h"\ + ".\lua_apr.h"\ + ".\lua_config.h"\ + ".\lua_request.h"\ + ".\lua_vmprep.h"\ + ".\mod_lua.h"\ + diff --git a/modules/lua/mod_lua.dsp b/modules/lua/mod_lua.dsp new file mode 100644 index 0000000..ef3294e --- /dev/null +++ b/modules/lua/mod_lua.dsp @@ -0,0 +1,163 @@ +# Microsoft Developer Studio Project File - Name="mod_lua" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102 + +CFG=mod_lua - Win32 Release +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "mod_lua.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "mod_lua.mak" CFG="mod_lua - Win32 Release" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "mod_lua - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library") +!MESSAGE "mod_lua - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +MTL=midl.exe +RSC=rc.exe + +!IF "$(CFG)" == "mod_lua - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MD /W3 /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FD /c +# ADD CPP /nologo /MD /W3 /O2 /Oy- /Zi /I "../../include" /I "../../srclib/apr/include" /I "../../srclib/apr-util/include" /I "../../srclib/lua/src" /I "../ssl" /I "../database" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_LUA_DECLARE_EXPORT" /Fd"Release\mod_lua_src" /FD /c +# ADD BASE MTL /nologo /D "NDEBUG" /win32 +# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32 +# ADD BASE RSC /l 0x409 /d "NDEBUG" +# ADD RSC /l 0x409 /fo"Release/mod_lua.res" /i "../../include" /i "../../srclib/apr/include" /d "NDEBUG" /d BIN_NAME="mod_lua.so" /d LONG_NAME="lua_module for Apache" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib ws2_32.lib /nologo /subsystem:windows /dll /out:".\Release\mod_lua.so" /base:@..\..\os\win32\BaseAddr.ref,mod_lua.so +# ADD LINK32 kernel32.lib ws2_32.lib lua51.lib /nologo /subsystem:windows /dll /incremental:no /debug /out:".\Release\mod_lua.so" /base:@..\..\os\win32\BaseAddr.ref,mod_lua.so /opt:ref /libpath:"../../srclib/lua/src" +# Begin Special Build Tool +TargetPath=.\Release\mod_lua.so +SOURCE="$(InputPath)" +PostBuild_Desc=Embed .manifest +PostBuild_Cmds=if exist $(TargetPath).manifest mt.exe -manifest $(TargetPath).manifest -outputresource:$(TargetPath);2 +# End Special Build Tool + +!ELSEIF "$(CFG)" == "mod_lua - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MDd /W3 /EHsc /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FD /c +# ADD CPP /nologo /MDd /W3 /EHsc /Zi /Od /I "../../include" /I "../../srclib/apr/include" /I "../../srclib/apr-util/include" /I "../../srclib/lua/src" /I "../ssl" /I "../database" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_LUA_DECLARE_EXPORT" /Fd"Debug\mod_lua_src" /FD /c +# ADD BASE MTL /nologo /D "_DEBUG" /win32 +# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32 +# ADD BASE RSC /l 0x409 /d "_DEBUG" +# ADD RSC /l 0x409 /fo"Debug/mod_lua.res" /i "../../include" /i "../../srclib/apr/include" /d "_DEBUG" /d BIN_NAME="mod_lua.so" /d LONG_NAME="lua_module for Apache" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib ws2_32.lib /nologo /subsystem:windows /dll /incremental:no /debug /out:".\Debug\mod_lua.so" /base:@..\..\os\win32\BaseAddr.ref,mod_lua.so +# ADD LINK32 kernel32.lib ws2_32.lib lua51.lib /nologo /subsystem:windows /dll /incremental:no /debug /out:".\Debug\mod_lua.so" /base:@..\..\os\win32\BaseAddr.ref,mod_lua.so /libpath:"../../srclib/lua/src" +# Begin Special Build Tool +TargetPath=.\Debug\mod_lua.so +SOURCE="$(InputPath)" +PostBuild_Desc=Embed .manifest +PostBuild_Cmds=if exist $(TargetPath).manifest mt.exe -manifest $(TargetPath).manifest -outputresource:$(TargetPath);2 +# End Special Build Tool + +!ENDIF + +# Begin Target + +# Name "mod_lua - Win32 Release" +# Name "mod_lua - Win32 Debug" +# Begin Source File + +SOURCE=.\lua_apr.c +# End Source File +# Begin Source File + +SOURCE=.\lua_apr.h +# End Source File +# Begin Source File + +SOURCE=.\lua_config.c +# End Source File +# Begin Source File + +SOURCE=.\lua_config.h +# End Source File +# Begin Source File + +SOURCE=.\lua_passwd.c +# End Source File +# Begin Source File + +SOURCE=.\lua_passwd.h +# End Source File +# Begin Source File + +SOURCE=.\lua_request.c +# End Source File +# Begin Source File + +SOURCE=.\lua_request.h +# End Source File +# Begin Source File + +SOURCE=.\lua_vmprep.c +# End Source File +# Begin Source File + +SOURCE=.\lua_vmprep.h +# End Source File +# Begin Source File + +SOURCE=.\mod_lua.c +# End Source File +# Begin Source File + +SOURCE=.\mod_lua.h +# End Source File +# Begin Source File + +SOURCE=.\lua_dbd.c +# End Source File +# Begin Source File + +SOURCE=.\lua_dbd.h +# End Source File +# Begin Source File + +SOURCE=..\..\build\win32\httpd.rc +# End Source File +# End Target +# End Project diff --git a/modules/lua/mod_lua.h b/modules/lua/mod_lua.h new file mode 100644 index 0000000..0e49cdc --- /dev/null +++ b/modules/lua/mod_lua.h @@ -0,0 +1,177 @@ +/** + * 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. + */ + +#ifndef _MOD_LUA_H_ +#define _MOD_LUA_H_ + +#include <stdio.h> + +#include "httpd.h" +#include "http_core.h" +#include "http_config.h" +#include "http_request.h" +#include "http_log.h" +#include "http_protocol.h" +#include "ap_regex.h" + +#include "ap_config.h" +#include "util_filter.h" + +#include "apr_thread_rwlock.h" +#include "apr_strings.h" +#include "apr_tables.h" +#include "apr_hash.h" +#include "apr_buckets.h" +#include "apr_file_info.h" +#include "apr_time.h" +#include "apr_hooks.h" +#include "apr_reslist.h" + +#include "lua.h" +#include "lauxlib.h" +#include "lualib.h" + +#if LUA_VERSION_NUM > 501 +/* Load mode for lua_load() */ +#define lua_load(a,b,c,d) lua_load(a,b,c,d,NULL) +#define lua_resume(a,b) lua_resume(a, NULL, b) +#define luaL_setfuncs_compat(a,b) luaL_setfuncs(a,b,0) +#else +#define lua_rawlen(L,i) lua_objlen(L, (i)) +#define luaL_setfuncs_compat(a,b) luaL_register(a,NULL,b) +#endif +#if LUA_VERSION_NUM > 502 +#define lua_dump(a,b,c) lua_dump(a,b,c,0) +#endif + +/* Create a set of AP_LUA_DECLARE(type), AP_LUA_DECLARE_NONSTD(type) and + * AP_LUA_DECLARE_DATA with appropriate export and import tags for the platform + */ +#if !defined(WIN32) +#define AP_LUA_DECLARE(type) type +#define AP_LUA_DECLARE_NONSTD(type) type +#define AP_LUA_DECLARE_DATA +#elif defined(AP_LUA_DECLARE_STATIC) +#define AP_LUA_DECLARE(type) type __stdcall +#define AP_LUA_DECLARE_NONSTD(type) type +#define AP_LUA_DECLARE_DATA +#elif defined(AP_LUA_DECLARE_EXPORT) +#define AP_LUA_DECLARE(type) __declspec(dllexport) type __stdcall +#define AP_LUA_DECLARE_NONSTD(type) __declspec(dllexport) type +#define AP_LUA_DECLARE_DATA __declspec(dllexport) +#else +#define AP_LUA_DECLARE(type) __declspec(dllimport) type __stdcall +#define AP_LUA_DECLARE_NONSTD(type) __declspec(dllimport) type +#define AP_LUA_DECLARE_DATA __declspec(dllimport) +#endif + + +#include "lua_request.h" +#include "lua_vmprep.h" + +typedef enum { + AP_LUA_INHERIT_UNSET = -1, + AP_LUA_INHERIT_NONE = 0, + AP_LUA_INHERIT_PARENT_FIRST = 1, + AP_LUA_INHERIT_PARENT_LAST = 2 +} ap_lua_inherit_t; + +/** + * make a userdata out of a C pointer, and vice versa + * instead of using lightuserdata + */ +#ifndef lua_boxpointer +#define lua_boxpointer(L,u) (*(void **)(lua_newuserdata(L, sizeof(void *))) = (u)) +#define lua_unboxpointer(L,i) (*(void **)(lua_touserdata(L, i))) +#endif + +void ap_lua_rstack_dump(lua_State *L, request_rec *r, const char *msg); + +typedef struct +{ + apr_array_header_t *package_paths; + apr_array_header_t *package_cpaths; + + /** + * mapped handlers/filters + */ + apr_array_header_t *mapped_handlers; + apr_array_header_t *mapped_filters; + + apr_pool_t *pool; + + /** + * AP_LUA_SCOPE_ONCE | AP_LUA_SCOPE_REQUEST | AP_LUA_SCOPE_CONN | AP_LUA_SCOPE_SERVER + */ + unsigned int vm_scope; + unsigned int vm_min; + unsigned int vm_max; + + /* info for the hook harnesses */ + apr_hash_t *hooks; /* <wombat_hook_info> */ + + /* the actual directory being configured */ + const char *dir; + + /* Whether Lua scripts in a sub-dir are run before parents */ + ap_lua_inherit_t inherit; + + /** + * AP_LUA_CACHE_NEVER | AP_LUA_CACHE_STAT | AP_LUA_CACHE_FOREVER + */ + unsigned int codecache; + +} ap_lua_dir_cfg; + +typedef struct +{ + /* value of the LuaRoot directive */ + const char *root_path; +} ap_lua_server_cfg; + +typedef struct +{ + const char *function_name; + ap_lua_vm_spec *spec; +} mapped_request_details; + +typedef struct +{ + mapped_request_details *mapped_request_details; + apr_hash_t *request_scoped_vms; +} ap_lua_request_cfg; + +typedef struct +{ + lua_State *L; + const char *function; +} ap_lua_filter_ctx; + +extern module AP_MODULE_DECLARE_DATA lua_module; + +APR_DECLARE_EXTERNAL_HOOK(ap_lua, AP_LUA, int, lua_open, + (lua_State *L, apr_pool_t *p)) + +APR_DECLARE_EXTERNAL_HOOK(ap_lua, AP_LUA, int, lua_request, + (lua_State *L, request_rec *r)) + +const char *ap_lua_ssl_val(apr_pool_t *p, server_rec *s, conn_rec *c, + request_rec *r, const char *var); + +int ap_lua_ssl_is_https(conn_rec *c); + +#endif /* !_MOD_LUA_H_ */ diff --git a/modules/lua/mod_lua.mak b/modules/lua/mod_lua.mak new file mode 100644 index 0000000..114d6bd --- /dev/null +++ b/modules/lua/mod_lua.mak @@ -0,0 +1,407 @@ +# Microsoft Developer Studio Generated NMAKE File, Based on mod_lua.dsp +!IF "$(CFG)" == "" +CFG=mod_lua - Win32 Release +!MESSAGE No configuration specified. Defaulting to mod_lua - Win32 Release. +!ENDIF + +!IF "$(CFG)" != "mod_lua - Win32 Release" && "$(CFG)" != "mod_lua - Win32 Debug" +!MESSAGE Invalid configuration "$(CFG)" specified. +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "mod_lua.mak" CFG="mod_lua - Win32 Release" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "mod_lua - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library") +!MESSAGE "mod_lua - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library") +!MESSAGE +!ERROR An invalid configuration is specified. +!ENDIF + +!IF "$(OS)" == "Windows_NT" +NULL= +!ELSE +NULL=nul +!ENDIF + +!IF "$(CFG)" == "mod_lua - Win32 Release" + +OUTDIR=.\Release +INTDIR=.\Release +DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep +# Begin Custom Macros +OutDir=.\Release +# End Custom Macros + +!IF "$(RECURSE)" == "0" + +ALL : "$(OUTDIR)\mod_lua.so" "$(DS_POSTBUILD_DEP)" + +!ELSE + +ALL : "libhttpd - Win32 Release" "libaprutil - Win32 Release" "libapr - Win32 Release" "$(OUTDIR)\mod_lua.so" "$(DS_POSTBUILD_DEP)" + +!ENDIF + +!IF "$(RECURSE)" == "1" +CLEAN :"libapr - Win32 ReleaseCLEAN" "libaprutil - Win32 ReleaseCLEAN" "libhttpd - Win32 ReleaseCLEAN" +!ELSE +CLEAN : +!ENDIF + -@erase "$(INTDIR)\lua_apr.obj" + -@erase "$(INTDIR)\lua_config.obj" + -@erase "$(INTDIR)\lua_dbd.obj" + -@erase "$(INTDIR)\lua_passwd.obj" + -@erase "$(INTDIR)\lua_request.obj" + -@erase "$(INTDIR)\lua_vmprep.obj" + -@erase "$(INTDIR)\mod_lua.obj" + -@erase "$(INTDIR)\mod_lua.res" + -@erase "$(INTDIR)\mod_lua_src.idb" + -@erase "$(INTDIR)\mod_lua_src.pdb" + -@erase "$(OUTDIR)\mod_lua.exp" + -@erase "$(OUTDIR)\mod_lua.lib" + -@erase "$(OUTDIR)\mod_lua.pdb" + -@erase "$(OUTDIR)\mod_lua.so" + +"$(OUTDIR)" : + if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" + +CPP=cl.exe +CPP_PROJ=/nologo /MD /W3 /Zi /O2 /Oy- /I "../../include" /I "../../srclib/apr/include" /I "../../srclib/apr-util/include" /I "../../srclib/lua/src" /I "../ssl" /I "../database" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_LUA_DECLARE_EXPORT" /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\mod_lua_src" /FD /c + +.c{$(INTDIR)}.obj:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.cpp{$(INTDIR)}.obj:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.cxx{$(INTDIR)}.obj:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.c{$(INTDIR)}.sbr:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.cpp{$(INTDIR)}.sbr:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.cxx{$(INTDIR)}.sbr:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +MTL=midl.exe +MTL_PROJ=/nologo /D "NDEBUG" /mktyplib203 /win32 +RSC=rc.exe +RSC_PROJ=/l 0x409 /fo"$(INTDIR)\mod_lua.res" /i "../../include" /i "../../srclib/apr/include" /d "NDEBUG" /d BIN_NAME="mod_lua.so" /d LONG_NAME="lua_module for Apache" +BSC32=bscmake.exe +BSC32_FLAGS=/nologo /o"$(OUTDIR)\mod_lua.bsc" +BSC32_SBRS= \ + +LINK32=link.exe +LINK32_FLAGS=kernel32.lib ws2_32.lib lua51.lib /nologo /subsystem:windows /dll /incremental:no /pdb:"$(OUTDIR)\mod_lua.pdb" /debug /out:"$(OUTDIR)\mod_lua.so" /implib:"$(OUTDIR)\mod_lua.lib" /libpath:"../../srclib/lua/src" /base:@..\..\os\win32\BaseAddr.ref,mod_lua.so /opt:ref +LINK32_OBJS= \ + "$(INTDIR)\lua_apr.obj" \ + "$(INTDIR)\lua_config.obj" \ + "$(INTDIR)\lua_passwd.obj" \ + "$(INTDIR)\lua_request.obj" \ + "$(INTDIR)\lua_vmprep.obj" \ + "$(INTDIR)\mod_lua.obj" \ + "$(INTDIR)\lua_dbd.obj" \ + "$(INTDIR)\mod_lua.res" \ + "..\..\srclib\apr\Release\libapr-1.lib" \ + "..\..\srclib\apr-util\Release\libaprutil-1.lib" \ + "..\..\Release\libhttpd.lib" + +"$(OUTDIR)\mod_lua.so" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) + $(LINK32) @<< + $(LINK32_FLAGS) $(LINK32_OBJS) +<< + +TargetPath=.\Release\mod_lua.so +SOURCE="$(InputPath)" +PostBuild_Desc=Embed .manifest +DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep + +# Begin Custom Macros +OutDir=.\Release +# End Custom Macros + +"$(DS_POSTBUILD_DEP)" : "$(OUTDIR)\mod_lua.so" + if exist .\Release\mod_lua.so.manifest mt.exe -manifest .\Release\mod_lua.so.manifest -outputresource:.\Release\mod_lua.so;2 + echo Helper for Post-build step > "$(DS_POSTBUILD_DEP)" + +!ELSEIF "$(CFG)" == "mod_lua - Win32 Debug" + +OUTDIR=.\Debug +INTDIR=.\Debug +DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep +# Begin Custom Macros +OutDir=.\Debug +# End Custom Macros + +!IF "$(RECURSE)" == "0" + +ALL : "$(OUTDIR)\mod_lua.so" "$(DS_POSTBUILD_DEP)" + +!ELSE + +ALL : "libhttpd - Win32 Debug" "libaprutil - Win32 Debug" "libapr - Win32 Debug" "$(OUTDIR)\mod_lua.so" "$(DS_POSTBUILD_DEP)" + +!ENDIF + +!IF "$(RECURSE)" == "1" +CLEAN :"libapr - Win32 DebugCLEAN" "libaprutil - Win32 DebugCLEAN" "libhttpd - Win32 DebugCLEAN" +!ELSE +CLEAN : +!ENDIF + -@erase "$(INTDIR)\lua_apr.obj" + -@erase "$(INTDIR)\lua_config.obj" + -@erase "$(INTDIR)\lua_dbd.obj" + -@erase "$(INTDIR)\lua_passwd.obj" + -@erase "$(INTDIR)\lua_request.obj" + -@erase "$(INTDIR)\lua_vmprep.obj" + -@erase "$(INTDIR)\mod_lua.obj" + -@erase "$(INTDIR)\mod_lua.res" + -@erase "$(INTDIR)\mod_lua_src.idb" + -@erase "$(INTDIR)\mod_lua_src.pdb" + -@erase "$(OUTDIR)\mod_lua.exp" + -@erase "$(OUTDIR)\mod_lua.lib" + -@erase "$(OUTDIR)\mod_lua.pdb" + -@erase "$(OUTDIR)\mod_lua.so" + +"$(OUTDIR)" : + if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" + +CPP=cl.exe +CPP_PROJ=/nologo /MDd /W3 /Zi /Od /I "../../include" /I "../../srclib/apr/include" /I "../../srclib/apr-util/include" /I "../../srclib/lua/src" /I "../ssl" /I "../database" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "AP_LUA_DECLARE_EXPORT" /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\mod_lua_src" /FD /EHsc /c + +.c{$(INTDIR)}.obj:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.cpp{$(INTDIR)}.obj:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.cxx{$(INTDIR)}.obj:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.c{$(INTDIR)}.sbr:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.cpp{$(INTDIR)}.sbr:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +.cxx{$(INTDIR)}.sbr:: + $(CPP) @<< + $(CPP_PROJ) $< +<< + +MTL=midl.exe +MTL_PROJ=/nologo /D "_DEBUG" /mktyplib203 /win32 +RSC=rc.exe +RSC_PROJ=/l 0x409 /fo"$(INTDIR)\mod_lua.res" /i "../../include" /i "../../srclib/apr/include" /d "_DEBUG" /d BIN_NAME="mod_lua.so" /d LONG_NAME="lua_module for Apache" +BSC32=bscmake.exe +BSC32_FLAGS=/nologo /o"$(OUTDIR)\mod_lua.bsc" +BSC32_SBRS= \ + +LINK32=link.exe +LINK32_FLAGS=kernel32.lib ws2_32.lib lua51.lib /nologo /subsystem:windows /dll /incremental:no /pdb:"$(OUTDIR)\mod_lua.pdb" /debug /out:"$(OUTDIR)\mod_lua.so" /implib:"$(OUTDIR)\mod_lua.lib" /libpath:"../../srclib/lua/src" /base:@..\..\os\win32\BaseAddr.ref,mod_lua.so +LINK32_OBJS= \ + "$(INTDIR)\lua_apr.obj" \ + "$(INTDIR)\lua_config.obj" \ + "$(INTDIR)\lua_passwd.obj" \ + "$(INTDIR)\lua_request.obj" \ + "$(INTDIR)\lua_vmprep.obj" \ + "$(INTDIR)\mod_lua.obj" \ + "$(INTDIR)\lua_dbd.obj" \ + "$(INTDIR)\mod_lua.res" \ + "..\..\srclib\apr\Debug\libapr-1.lib" \ + "..\..\srclib\apr-util\Debug\libaprutil-1.lib" \ + "..\..\Debug\libhttpd.lib" + +"$(OUTDIR)\mod_lua.so" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) + $(LINK32) @<< + $(LINK32_FLAGS) $(LINK32_OBJS) +<< + +TargetPath=.\Debug\mod_lua.so +SOURCE="$(InputPath)" +PostBuild_Desc=Embed .manifest +DS_POSTBUILD_DEP=$(INTDIR)\postbld.dep + +# Begin Custom Macros +OutDir=.\Debug +# End Custom Macros + +"$(DS_POSTBUILD_DEP)" : "$(OUTDIR)\mod_lua.so" + if exist .\Debug\mod_lua.so.manifest mt.exe -manifest .\Debug\mod_lua.so.manifest -outputresource:.\Debug\mod_lua.so;2 + echo Helper for Post-build step > "$(DS_POSTBUILD_DEP)" + +!ENDIF + + +!IF "$(NO_EXTERNAL_DEPS)" != "1" +!IF EXISTS("mod_lua.dep") +!INCLUDE "mod_lua.dep" +!ELSE +!MESSAGE Warning: cannot find "mod_lua.dep" +!ENDIF +!ENDIF + + +!IF "$(CFG)" == "mod_lua - Win32 Release" || "$(CFG)" == "mod_lua - Win32 Debug" + +!IF "$(CFG)" == "mod_lua - Win32 Release" + +"libapr - Win32 Release" : + cd ".\..\..\srclib\apr" + $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Release" + cd "..\..\modules\lua" + +"libapr - Win32 ReleaseCLEAN" : + cd ".\..\..\srclib\apr" + $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Release" RECURSE=1 CLEAN + cd "..\..\modules\lua" + +!ELSEIF "$(CFG)" == "mod_lua - Win32 Debug" + +"libapr - Win32 Debug" : + cd ".\..\..\srclib\apr" + $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Debug" + cd "..\..\modules\lua" + +"libapr - Win32 DebugCLEAN" : + cd ".\..\..\srclib\apr" + $(MAKE) /$(MAKEFLAGS) /F ".\libapr.mak" CFG="libapr - Win32 Debug" RECURSE=1 CLEAN + cd "..\..\modules\lua" + +!ENDIF + +!IF "$(CFG)" == "mod_lua - Win32 Release" + +"libaprutil - Win32 Release" : + cd ".\..\..\srclib\apr-util" + $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Release" + cd "..\..\modules\lua" + +"libaprutil - Win32 ReleaseCLEAN" : + cd ".\..\..\srclib\apr-util" + $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Release" RECURSE=1 CLEAN + cd "..\..\modules\lua" + +!ELSEIF "$(CFG)" == "mod_lua - Win32 Debug" + +"libaprutil - Win32 Debug" : + cd ".\..\..\srclib\apr-util" + $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Debug" + cd "..\..\modules\lua" + +"libaprutil - Win32 DebugCLEAN" : + cd ".\..\..\srclib\apr-util" + $(MAKE) /$(MAKEFLAGS) /F ".\libaprutil.mak" CFG="libaprutil - Win32 Debug" RECURSE=1 CLEAN + cd "..\..\modules\lua" + +!ENDIF + +!IF "$(CFG)" == "mod_lua - Win32 Release" + +"libhttpd - Win32 Release" : + cd ".\..\.." + $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Release" + cd ".\modules\lua" + +"libhttpd - Win32 ReleaseCLEAN" : + cd ".\..\.." + $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Release" RECURSE=1 CLEAN + cd ".\modules\lua" + +!ELSEIF "$(CFG)" == "mod_lua - Win32 Debug" + +"libhttpd - Win32 Debug" : + cd ".\..\.." + $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Debug" + cd ".\modules\lua" + +"libhttpd - Win32 DebugCLEAN" : + cd ".\..\.." + $(MAKE) /$(MAKEFLAGS) /F ".\libhttpd.mak" CFG="libhttpd - Win32 Debug" RECURSE=1 CLEAN + cd ".\modules\lua" + +!ENDIF + +SOURCE=..\..\build\win32\httpd.rc + +!IF "$(CFG)" == "mod_lua - Win32 Release" + + +"$(INTDIR)\mod_lua.res" : $(SOURCE) "$(INTDIR)" + $(RSC) /l 0x409 /fo"$(INTDIR)\mod_lua.res" /i "../../include" /i "../../srclib/apr/include" /i "../../build\win32" /d "NDEBUG" /d BIN_NAME="mod_lua.so" /d LONG_NAME="lua_module for Apache" $(SOURCE) + + +!ELSEIF "$(CFG)" == "mod_lua - Win32 Debug" + + +"$(INTDIR)\mod_lua.res" : $(SOURCE) "$(INTDIR)" + $(RSC) /l 0x409 /fo"$(INTDIR)\mod_lua.res" /i "../../include" /i "../../srclib/apr/include" /i "../../build\win32" /d "_DEBUG" /d BIN_NAME="mod_lua.so" /d LONG_NAME="lua_module for Apache" $(SOURCE) + + +!ENDIF + +SOURCE=.\lua_apr.c + +"$(INTDIR)\lua_apr.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\lua_config.c + +"$(INTDIR)\lua_config.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\lua_dbd.c + +"$(INTDIR)\lua_dbd.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\lua_passwd.c + +"$(INTDIR)\lua_passwd.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\lua_request.c + +"$(INTDIR)\lua_request.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\lua_vmprep.c + +"$(INTDIR)\lua_vmprep.obj" : $(SOURCE) "$(INTDIR)" + + +SOURCE=.\mod_lua.c + +"$(INTDIR)\mod_lua.obj" : $(SOURCE) "$(INTDIR)" + + + +!ENDIF + diff --git a/modules/lua/test/helpers.lua b/modules/lua/test/helpers.lua new file mode 100644 index 0000000..79bd269 --- /dev/null +++ b/modules/lua/test/helpers.lua @@ -0,0 +1,36 @@ +module("helpers", package.seeall) + +local io = require("io") +local http = require("socket.http") +local string = require("string") + +base_url = "http://localhost" + +function get(uri) + return http.request(base_url .. uri) +end + +function post(uri, body) + local function do_it(body) + local flat + if (type(body) == "table") then + i = 1 + for k, v in pairs(body) do + if i == 1 then + flat = k .. "=" ..v + else + flat = flat .. "&" .. k .. "=" .. v + end + i = i + 1 + end + else + flat = body; + end + return http.request(base_url .. uri, flat) + end + if body then + return do_it(body) + else + return do_it + end +end
\ No newline at end of file diff --git a/modules/lua/test/htdocs/config_tests.lua b/modules/lua/test/htdocs/config_tests.lua new file mode 100644 index 0000000..698bedf --- /dev/null +++ b/modules/lua/test/htdocs/config_tests.lua @@ -0,0 +1,37 @@ +-- 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. + +require 'string' + +local count = 0 + +function handle(r) + r:puts("success in handle " .. count) +end + +function handle_server_vm(r) + r:puts("hello from server scope " .. count) + count = count + 1 +end + +function handle_request_vm(r) + r:puts("hello from request scope " .. count) + count = count + 1 +end + +function handle_conn_vm(r) + r:puts("hello from request scope " .. count) + count = count + 1 +end
\ No newline at end of file diff --git a/modules/lua/test/htdocs/filters.lua b/modules/lua/test/htdocs/filters.lua new file mode 100644 index 0000000..cad0ca8 --- /dev/null +++ b/modules/lua/test/htdocs/filters.lua @@ -0,0 +1,7 @@ + +local s = require 'string' + +function handle_simple(r) + -- r:addoutputfilter("wombathood") + r:puts("added wombathood") +end
\ No newline at end of file diff --git a/modules/lua/test/htdocs/find_me.txt b/modules/lua/test/htdocs/find_me.txt new file mode 100644 index 0000000..cb96e9e --- /dev/null +++ b/modules/lua/test/htdocs/find_me.txt @@ -0,0 +1 @@ +please find me
\ No newline at end of file diff --git a/modules/lua/test/htdocs/headers.lua b/modules/lua/test/htdocs/headers.lua new file mode 100644 index 0000000..35938ea --- /dev/null +++ b/modules/lua/test/htdocs/headers.lua @@ -0,0 +1,6 @@ +function handle(r) + local host = r.headers_in['host'] + r:debug(host) + r:puts(host) + r.headers_out['wombat'] = 'lua' +end diff --git a/modules/lua/test/htdocs/hooks.lua b/modules/lua/test/htdocs/hooks.lua new file mode 100644 index 0000000..b8a8248 --- /dev/null +++ b/modules/lua/test/htdocs/hooks.lua @@ -0,0 +1,29 @@ +require 'string' +require 'apache2' + +function translate_name(r) + if r.uri == "/translate-name" then + r.uri = "/find_me.txt" + return apache2.DECLINED + end + return apache2.DECLINED +end + +function translate_name2(r) + if r.uri == "/translate-name2" then + r.uri = "/find_me.txt" + return apache2.DECLINED + end + return apache2.DECLINED +end + +function fixups_test(r) + -- r:err("KABAZ") + if r.uri == "/test_fixupstest" then + -- r:err("KABIZ") + r.status = 201 + return apache2.OK + end + -- r:err("ZIBAK") + return apache2.DECLINED +end
\ No newline at end of file diff --git a/modules/lua/test/htdocs/other.lua b/modules/lua/test/htdocs/other.lua new file mode 100644 index 0000000..90c6ed2 --- /dev/null +++ b/modules/lua/test/htdocs/other.lua @@ -0,0 +1,21 @@ +-- 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. + +module("other") + +function doit(r) + r:debug("doing it...") + r:puts("Do It!\n") +end diff --git a/modules/lua/test/htdocs/simple.lua b/modules/lua/test/htdocs/simple.lua new file mode 100644 index 0000000..a3f8861 --- /dev/null +++ b/modules/lua/test/htdocs/simple.lua @@ -0,0 +1,4 @@ +function handle(r) + r.content_type = "text/plain" + r:puts("Hi there!") +end diff --git a/modules/lua/test/htdocs/test.lua b/modules/lua/test/htdocs/test.lua new file mode 100644 index 0000000..c0b96ab --- /dev/null +++ b/modules/lua/test/htdocs/test.lua @@ -0,0 +1,129 @@ +-- 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. + +require 'string' + +function print_args(r, simple, complex) + local s = " %s: %s\n" + r:puts(" simple:\n") + for k, v in pairs(simple) do + r:puts(s:format(k, v)) + end + + s = " %s: " + r:puts(" complex:\n") + for k, ary in pairs(complex) do + r:puts(s:format(k)) + for i=1, #ary do + r:puts(ary[i]) + if i < #ary then r:puts(", ") end + end + r:puts("\n") + end +end + +function debug_stuff(r) + r:debug("This is a debug log message") + -- r:info("This is an info log message") + -- r:notice("This is an notice log message") + -- r:warn("This is an warn log message") + -- r:err("This is an err log message") + -- r:alert("This is an alert log message") + -- r:crit("This is an crit log message") + -- r:emerg("This is an emerg log message") +end + +function handle(r) + r:puts("hello Lua world\n") + r:puts("Query args:\n") + + print_args(r, r:parseargs()); + + debug_stuff(r) + + r:puts("HTTP Method:\n " .. r.method .. "\n") + + if r.method == 'POST' then + print_args(r, r:parsebody()) + end + + require("other") + r:puts("loaded relative to script:\n ") + other.doit(r) + + r:puts("loaded from LuaPackagePath:\n") + require("kangaroo"); + kangaroo.hop(r); +end + +function handle_foo(r) + r:puts("Handler FOO!\n") + r.status = 201 + r:debug("set status to 201") +end + + +function handle_attributes(r) + local function pf(name) + r:puts(("%s: %s\n"):format(name, tostring(r[name]))) + end + + pf("status") + r.status = 201 + pf("status") + r:puts("\n") + + pf("content_type") + r.content_type = "text/plain?charset=ascii" + pf("content_type") + r:puts("\n") + + pf("method") + pf("protocol") + pf("assbackwards") + pf("the_request") + pf("range") + pf("content_encoding") + pf("user") + pf("unparsed_uri") + pf("ap_auth_type") + pf("uri") + pf("filename") + pf("canonical_filename") + pf("path_info") + pf("args") + + r:puts("\n") +end + +function test_headers(r) + r:puts("test getting and setting headers here\n") +end + +function handle_quietly(r) + r:puts("hello!") +end + +function handle_regex(r) + r:puts("matched in handle_regex") +end + +function handle_serverversion(r) + r:puts(apache2.version) +end + +function handle_fixupstest(r) + r:puts("status is " .. r.status) +end
\ No newline at end of file diff --git a/modules/lua/test/lib/kangaroo.lua b/modules/lua/test/lib/kangaroo.lua new file mode 100644 index 0000000..00ba3e5 --- /dev/null +++ b/modules/lua/test/lib/kangaroo.lua @@ -0,0 +1,19 @@ +-- 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. +module("kangaroo") + +function hop(r) + r:puts(" hop hop!\n") +end diff --git a/modules/lua/test/moonunit.lua b/modules/lua/test/moonunit.lua new file mode 100644 index 0000000..8537a1e --- /dev/null +++ b/modules/lua/test/moonunit.lua @@ -0,0 +1,52 @@ +-- 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. + +module("moonunit", package.seeall) + +TestCase = {} + +function TestCase:new(it) + it = it or {} + setmetatable(it, self) + self.__index = self + return it +end + +function TestCase:run(args) + args = args or arg + local function run_test(t, name) + local status, err = pcall(t, self) + if status then + print(("%-39s \27[32mpass\27[39m"):format("[" .. name .. "]")) + else + print(("%-39s \27[31mFAIL\27[39m %s"):format("[" .. name .. "]", err)) + end + end + + if (args and #args > 0) then + for _, v in ipairs(args) do + if type(self[v]) == "function" then + run_test(self[v], v) + else + print(("%-39s FAIL %s"):format("[" .. v .. "]", + "'" .. v .. "' doesn't appear to be a test function")) + end + end + else + for k, v in pairs(self) do + run_test(v, k) + end + end +end diff --git a/modules/lua/test/test.lua b/modules/lua/test/test.lua new file mode 100755 index 0000000..25da4d9 --- /dev/null +++ b/modules/lua/test/test.lua @@ -0,0 +1,126 @@ +#!/usr/bin/env lua + +-- 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. + +local mu = require "moonunit" +local http = require "helpers" + +http.base_url = "http://localhost:8008" + +local test = mu.TestCase:new{} + +function test:document_root() + local b, c = http.get "/document_root.lua" + assert(200 == c, "expected status code 200, got " .. c) + assert(b:find("test"), "test not found in document root") +end + +function test:basic_get() + local b, c = http.get "/basic" + assert(200 == c, "expected status code 200, got " .. c) + assert(b:find("hello Lua world"), "'hello Lua world' not found in response") +end + +function test:quietly() + local b, c = http.get "/test_quietly" + assert(200 == c, "unexpected response code " .. c) + assert(b == 'hello!', "unexpected response body [" .. b .. "]") +end + +function test.basic_post() + local b, c = http.post "/basic" "hello=7&hello=1" + assert(200 == c, "expected status code 200, got " .. c) + assert(b:find("complex:%s+hello: 7, 1\n"), "didn't find complex post parsing") + assert(b:find("simple:%s+hello: 7\n"), "didn't find simple post parsing") +end + +function test.basic_post_alt() + local b, c = http.post("/test_foo", "hello=7&hello=1") + assert(201 == c, "expected status code 200, got " .. c) + assert(b:find("Handler FOO!"), "unexpected output!") +end + +function test.post_with_table() + local b, c = http.post "/basic" { hello = "7" } + assert(200 == c, "expected status code 200, got " .. c) + assert(b:find("hello: 7"), "didn't get expected post data [" .. b .."]") + + b, c = http.post "/basic" { hello = "7", goodbye = "8" } + + assert(200 == c, "expected status code 200, got " .. c) + assert(b:find("hello: 7"), "didn't get expected post data [" .. b .."]") + assert(b:find("goodbye: 8"), "didn't get expected post data [" .. b .."]") +end + +function test:simple_filter() + local b, c = http.get "/filter/simple" + assert(200 == c, "expected status code 200, got " .. c) +end + +function test:request_attributes() + local r, c = http.get "/test_attributes?yes=no" + assert(201 == c, "expected status code 201, got " .. c) + + assert(r:find("status: 200\nstatus: 201"), "changing status code failed") + assert(r:find("method: GET"), "method wasn't reported correctly") + assert(r:find("protocol: HTTP/1.1"), "protocol reported incorrectly") + assert(r:find("assbackwards: false"), "assbackwards reported incorrectly") + assert(r:find("args: yes=no"), "args not reported correctly") +end + +function test:map_regex() + local r, c = http.get "/test_regex" + assert(200 == c, "expected status code 200, got " .. c) + assert(r:find("matched in handle_regex"), "didn't find 'matched in handle_regex'") +end + +function test:map_regex2() + local r, c = http.get "/test_regex?a=8" + assert(200 == c, "expected status code 200, got " .. c) + assert(r:find("matched in handle_regex"), "didn't find 'matched in handle_regex'") +end + +function test:translate_name_hook() + local r, c = http.get "/translate-name" + assert(200 == c, "expected 200 got " .. c) + assert(r:find("please find me"), "didn't get expected static file :-(, instead got " .. r) +end + +function test:translate_name_hook2() + local r, c = http.get "/translate-name2" + assert(200 == c, "expected 200 got " .. c) + assert(r:find("please find me"), "didn't get expected static file :-(, instead got " .. r) +end + +function test:server_version() + local r, c = http.get "/test_serverversion" + assert(200 == c) + assert(r:find("Apache/2"), "version isn't Apache/2, but is " .. r) +end + +function test:fixups_hook() + local r, c = http.get "/test_fixupstest" + assert(201 == c, "incorrect status code returned, expected 201 got " .. c) + assert(r:find("status is 201"), "handler sees incorrect status") +end + +function test:simple() + local r, c = http.get "/simple.lua" + assert(200 == c, "incorrect status code returned, expected 200 got " .. c) + assert(r:find("Hi"), "Didn't find 'Hi'") +end + +test:run() diff --git a/modules/lua/test/test_httpd.conf b/modules/lua/test/test_httpd.conf new file mode 100644 index 0000000..27e3a50 --- /dev/null +++ b/modules/lua/test/test_httpd.conf @@ -0,0 +1,31 @@ +# Customize these two values for your Apache2 install +ServerRoot "/Users/brianm/.opt/httpd-2.2.3-worker-for-lua" +DocumentRoot "/Users/brianm/src/wombat/test/htdocs" + +# Customize this value to point to the top of mod_wombat's test dir +LuaRoot /Users/brianm/src/wombat/test + +Listen 8000 + +LoadModule lua_module modules/mod_lua.so + +AddHandler lua-script .lua + +#LuaConfig httpd_config.lua configure + +LuaMapHandler /basic /Users/brianm/src/wombat/test/htdocs/test.lua +LuaMapHandler /filter/simple /Users/brianm/src/wombat/test/htdocs/filters.lua handle_simple +LuaMapHandler ^/(\w+)_(\w+)$ /Users/brianm/src/wombat/test/htdocs/$1.lua handle_$2 + +LuaHookTranslateName htdocs/hooks.lua translate_name +LuaHookTranslateName htdocs/hooks.lua translate_name2 + +LuaHookFixups htdocs/hooks.lua fixups_test + +LuaPackagePath lib/?.lua + +# stat | forever | never +LuaCodeCache stat + +ErrorLog logs/error_log +LogLevel debug |