�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2F'>httpd-2.4.63</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fmodules%2F'>modules</a>/<a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fmodules%2Flua%2F'>lua</a>/</p><hr><h3>✏️ Editing: lua_request.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/**
 * 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 &quot;License&quot;); 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 &quot;AS IS&quot; 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 &quot;mod_lua.h&quot;
#include &quot;lua_apr.h&quot;
#include &quot;lua_dbd.h&quot;
#include &quot;lua_passwd.h&quot;
#include &quot;scoreboard.h&quot;
#include &quot;util_md5.h&quot;
#include &quot;util_script.h&quot;
#include &quot;util_varbuf.h&quot;
#include &quot;apr_date.h&quot;
#include &quot;apr_pools.h&quot;
#include &quot;apr_thread_mutex.h&quot;
#include &quot;apr_tables.h&quot;
#include &quot;util_cookies.h&quot;

#define APR_WANT_BYTEFUNC
#include &quot;apr_want.h&quot;

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) &quot;Lua Stack Dump: [%s]&quot;, msg);
    for (i = 1; i &lt;= top; i++) {
        int t = lua_type(L, i);
        switch (t) {
        case LUA_TSTRING:{
                ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03001)
                              &quot;%d:  &#039;%s&#039;&quot;, i, lua_tostring(L, i));
                break;
            }
        case LUA_TUSERDATA:{
                ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03002)
                              &quot;%d:  userdata&quot;, i);
                break;
            }
        case LUA_TLIGHTUSERDATA:{
                ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03003)
                              &quot;%d:  lightuserdata&quot;, i);
                break;
            }
        case LUA_TNIL:{
                ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03004)
                              &quot;%d:  NIL&quot;, i);
                break;
            }
        case LUA_TNONE:{
                ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03005)
                              &quot;%d:  None&quot;, i);
                break;
            }
        case LUA_TBOOLEAN:{
                ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03006)
                              &quot;%d:  %s&quot;, i,
                              lua_toboolean(L, i) ? &quot;true&quot; : &quot;false&quot;);
                break;
            }
        case LUA_TNUMBER:{
                ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03007)
                              &quot;%d:  %g&quot;, i, lua_tonumber(L, i));
                break;
            }
        case LUA_TTABLE:{
                ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03008)
                              &quot;%d:  &lt;table&gt;&quot;, i);
                break;
            }
        case LUA_TFUNCTION:{
                ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03009)
                              &quot;%d:  &lt;function&gt;&quot;, i);
                break;
            }
        default:{
                ap_log_rerror(APLOG_MARK, APLOG_INFO, 0, r, APLOGNO(03010)
                              &quot;%d:  unknown: -[%s]-&quot;, 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, &quot;Apache2.Request&quot;);
    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&lt;s,t&gt;, table&lt;s,s&gt;] */
    /* rstack_dump(L, RRR, &quot;start of cb&quot;); */
    /* L is [table&lt;s,t&gt;, table&lt;s,s&gt;] */
    /* build complex */

    lua_getfield(L, -1, key);   /* [VALUE, table&lt;s,t&gt;, table&lt;s,s&gt;] */
    /* rstack_dump(L, RRR, &quot;after getfield&quot;); */
    t = lua_type(L, -1);
    switch (t) {
    case LUA_TNIL:
    case LUA_TNONE:{
            lua_pop(L, 1);      /* [table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_newtable(L);    /* [array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_pushnumber(L, 1);       /* [1, array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_pushstring(L, value);   /* [string, 1, array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_settable(L, -3);        /* [array, table&lt;s,t&gt;, table&lt;s,s&gt;]  */
            lua_setfield(L, -2, key);   /* [table&lt;s,t&gt;, table&lt;s,s&gt;] */
            break;
        }
    case LUA_TTABLE:{
            /* [array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            int size = lua_rawlen(L, -1);
            lua_pushnumber(L, size + 1);        /* [#, array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_pushstring(L, value);   /* [string, #, array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_settable(L, -3);        /* [array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_setfield(L, -2, key);   /* [table&lt;s,t&gt;, table&lt;s,s&gt;] */
            break;
        }
    }

    /* L is [table&lt;s,t&gt;, table&lt;s,s&gt;] */
    /* build simple */
    lua_getfield(L, -2, key);   /* [VALUE, table&lt;s,s&gt;, table&lt;s,t&gt;] */
    if (lua_isnoneornil(L, -1)) {       /* only set if not already set */
        lua_pop(L, 1);          /* [table&lt;s,s&gt;, table&lt;s,t&gt;]] */
        lua_pushstring(L, value);       /* [string, table&lt;s,s&gt;, table&lt;s,t&gt;] */
        lua_setfield(L, -3, key);       /* [table&lt;s,s&gt;, table&lt;s,t&gt;]  */
    }
    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&lt;s,t&gt;, table&lt;s,s&gt;] */
    /* rstack_dump(L, RRR, &quot;start of cb&quot;); */
    /* L is [table&lt;s,t&gt;, table&lt;s,s&gt;] */
    /* build complex */

    lua_getfield(L, -1, key);   /* [VALUE, table&lt;s,t&gt;, table&lt;s,s&gt;] */
    /* rstack_dump(L, RRR, &quot;after getfield&quot;); */
    t = lua_type(L, -1);
    switch (t) {
    case LUA_TNIL:
    case LUA_TNONE:{
            lua_pop(L, 1);      /* [table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_newtable(L);    /* [array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_pushnumber(L, 1);       /* [1, array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_pushlstring(L, value, len);   /* [string, 1, array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_settable(L, -3);        /* [array, table&lt;s,t&gt;, table&lt;s,s&gt;]  */
            lua_setfield(L, -2, key);   /* [table&lt;s,t&gt;, table&lt;s,s&gt;] */
            break;
        }
    
    case LUA_TTABLE:{
            /* [array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            int size = lua_rawlen(L, -1);
            lua_pushnumber(L, size + 1);        /* [#, array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_pushlstring(L, value, len);   /* [string, #, array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_settable(L, -3);        /* [array, table&lt;s,t&gt;, table&lt;s,s&gt;] */
            lua_setfield(L, -2, key);   /* [table&lt;s,t&gt;, table&lt;s,s&gt;] */
            break;
        }
    }

    /* L is [table&lt;s,t&gt;, table&lt;s,s&gt;] */
    /* build simple */
    lua_getfield(L, -2, key);   /* [VALUE, table&lt;s,s&gt;, table&lt;s,t&gt;] */
    if (lua_isnoneornil(L, -1)) {       /* only set if not already set */
        lua_pop(L, 1);          /* [table&lt;s,s&gt;, table&lt;s,t&gt;]] */
        lua_pushlstring(L, value, len);       /* [string, table&lt;s,s&gt;, table&lt;s,t&gt;] */
        lua_setfield(L, -3, key);       /* [table&lt;s,s&gt;, table&lt;s,t&gt;]  */
    }
    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;

    *rbuf = NULL;
    *size = 0;

    if ((rc = ap_setup_client_block(r, REQUEST_CHUNKED_ERROR))) {
        return (rc);
    }
    if (ap_should_client_block(r)) {

        /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
        apr_off_t    len_read = -1;
        apr_off_t    rpos = 0;
        apr_off_t length = r-&gt;remaining;
        /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

        if (maxsize != 0 &amp;&amp; length &gt; maxsize) {
            return APR_EINCOMPLETE; /* Only room for incomplete data chunk :( */
        }
        *rbuf = (const char *) apr_pcalloc(r-&gt;pool, (apr_size_t) (length) + 1);
        while ((rpos &lt; length)
               &amp;&amp; (len_read = ap_get_client_block(r, (char *) *rbuf + rpos,
                                               length - rpos)) &gt; 0) {
            rpos += len_read;
        }
        if (len_read &lt; 0) {
            return APR_EINCOMPLETE;
        }
        *size = rpos;
    }
    else {
        rc = DONE;
    }

    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;

    *size = 0;

    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-&gt;remaining;

        *size = length;
        while ((len_read =
                    ap_get_client_block(r, argsbuffer,
                                        sizeof(argsbuffer))) &gt; 0) {
            if ((rpos + len_read) &gt; 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;
        }
    }
    else {
        rc = DONE;
    }

    return rc;
}

/* expose apr_table as (r/o) lua table */
static int req_aprtable2luatable(lua_State *L, apr_table_t *t)
{
    lua_newtable(L);
    lua_newtable(L);            /* [table, table] */
    apr_table_do(req_aprtable2luatable_cb, L, t, NULL);
    return 2;                   /* [table&lt;string, string&gt;, table&lt;string, array&lt;string&gt;&gt;] */
}

static int req_headers_in_table(lua_State *L)
{
    request_rec *r = ap_lua_check_request_rec(L, 1);
    return req_aprtable2luatable(L, r-&gt;headers_in);
}
static int req_headers_out_table(lua_State *L)
{
    request_rec *r = ap_lua_check_request_rec(L, 1);
    return req_aprtable2luatable(L, r-&gt;headers_out);
}
static int req_err_headers_out_table(lua_State *L)
{
    request_rec *r = ap_lua_check_request_rec(L, 1);
    return req_aprtable2luatable(L, r-&gt;err_headers_out);
}
static int req_notes_table(lua_State *L)
{
    request_rec *r = ap_lua_check_request_rec(L, 1);
    return req_aprtable2luatable(L, r-&gt;notes);
}
static int req_subprocess_env_table(lua_State *L)
{
    request_rec *r = ap_lua_check_request_rec(L, 1);
    return req_aprtable2luatable(L, r-&gt;subprocess_env);
}
/* 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, &amp;form_table);
    apr_table_do(req_aprtable2luatable_cb, L, form_table, NULL);
    return 2;                   /* [table&lt;string, string&gt;, table&lt;string, array&lt;string&gt;&gt;] */
}

/* 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 &lt; nsize) return NULL;
    for (p = 0; p &lt;= (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-&gt;pool, 256);
    contentType = apr_table_get(r-&gt;headers_in, &quot;Content-Type&quot;);
    lua_newtable(L);
    lua_newtable(L);            /* [table, table] */    
    if (contentType != NULL &amp;&amp; (sscanf(contentType, &quot;multipart/form-data; boundary=%250c&quot;, 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, &amp;data, (apr_off_t*) &amp;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, &quot;\r\n\r\n&quot;);
            if (!crlf) break;
            end = ap_lua_binstrstr(crlf, (size - (crlf - data)), multipart, len);
            if (end == NULL) break;
            key = (char *) apr_pcalloc(r-&gt;pool, 256);
            filename = (char *) apr_pcalloc(r-&gt;pool, 256);
            if (end - crlf &lt;= 8) break;
            vlen = end - crlf - 8;
            buffer = (char *) apr_pcalloc(r-&gt;pool, vlen+1);
            memcpy(buffer, crlf + 4, vlen);
            sscanf(start + len + 2,
                &quot;Content-Disposition: form-data; name=\&quot;%255[^\&quot;]\&quot;; filename=\&quot;%255[^\&quot;]\&quot;&quot;,
                key, filename);
            if (*key) {
                req_aprtable2luatable_cb_len(L, key, buffer, vlen);
            }
        }
    }
    else {
        char *buffer;
        res = ap_parse_form_data(r, NULL, &amp;pairs, -1, max_post_size);
        if (res == OK) {
            while(pairs &amp;&amp; !apr_is_empty_array(pairs)) {
                ap_form_pair_t *pair = (ap_form_pair_t *) apr_array_pop(pairs);
                apr_brigade_length(pair-&gt;value, 1, &amp;len);
                size = (apr_size_t) len;
                buffer = apr_palloc(r-&gt;pool, size + 1);
                apr_brigade_flatten(pair-&gt;value, buffer, &amp;size);
                buffer[len] = 0;
                req_aprtable2luatable_cb(L, pair-&gt;name, buffer);
            }
        }
    }
    return 2;                   /* [table&lt;string, string&gt;, table&lt;string, array&lt;string&gt;&gt;] */
}


/*
 * 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 &gt; 0 &amp;&amp; r-&gt;remaining &gt; maxSize) {
            lua_pushnil(L);
            lua_pushliteral(L, &quot;Request body was larger than the permitted size.&quot;);
            return 2;
        }
        if (r-&gt;method_number != M_POST &amp;&amp; r-&gt;method_number != M_PUT)
            return (0);
        if (!filename) {
            const char     *data;

            if (lua_read_body(r, &amp;data, &amp;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(&amp;file, filename, APR_CREATE | APR_FOPEN_WRITE,
                               APR_FPROT_OS_DEFAULT, r-&gt;pool);
            lua_settop(L, 0);
            if (rc == APR_SUCCESS) {
                rc = lua_write_body(r, file, &amp;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 &lt;= 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, &amp;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) &quot;adding output filter %s&quot;,
                  name);
    ap_add_output_filter(name, L, r, r-&gt;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-&gt;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-&gt;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-&gt;pool, r-&gt;server, r-&gt;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-&gt;uri;
}

static const char *req_method_field(request_rec *r)
{
    return r-&gt;method;
}
static const char *req_handler_field(request_rec *r)
{
    return r-&gt;handler;
}
static const char *req_proxyreq_field(request_rec *r)
{
    switch (r-&gt;proxyreq) {
        case PROXYREQ_NONE:     return &quot;PROXYREQ_NONE&quot;;
        case PROXYREQ_PROXY:    return &quot;PROXYREQ_PROXY&quot;;
        case PROXYREQ_REVERSE:  return &quot;PROXYREQ_REVERSE&quot;;
        case PROXYREQ_RESPONSE: return &quot;PROXYREQ_RESPONSE&quot;;
        default: return NULL;
    }
}
static const char *req_hostname_field(request_rec *r)
{
    return r-&gt;hostname;
}

static const char *req_args_field(request_rec *r)
{
    return r-&gt;args;
}

static const char *req_path_info_field(request_rec *r)
{
    return r-&gt;path_info;
}

static const char *req_canonical_filename_field(request_rec *r)
{
    return r-&gt;canonical_filename;
}

static const char *req_filename_field(request_rec *r)
{
    return r-&gt;filename;
}

static const char *req_user_field(request_rec *r)
{
    return r-&gt;user;
}

static const char *req_unparsed_uri_field(request_rec *r)
{
    return r-&gt;unparsed_uri;
}

static const char *req_ap_auth_type_field(request_rec *r)
{
    return r-&gt;ap_auth_type;
}

static const char *req_content_encoding_field(request_rec *r)
{
    return r-&gt;content_encoding;
}

static const char *req_content_type_field(request_rec *r)
{
    return r-&gt;content_type;
}

static const char *req_range_field(request_rec *r)
{
    return r-&gt;range;
}

static const char *req_protocol_field(request_rec *r)
{
    return r-&gt;protocol;
}

static const char *req_the_request_field(request_rec *r)
{
    return r-&gt;the_request;
}

static const char *req_log_id_field(request_rec *r)
{
    return r-&gt;log_id;
}

static const char *req_useragent_ip_field(request_rec *r)
{
    return r-&gt;useragent_ip;
}

static int req_remaining_field(request_rec *r)
{
    return r-&gt;remaining;
}

static int req_status_field(request_rec *r)
{
    return r-&gt;status;
}

static int req_assbackwards_field(request_rec *r)
{
    return r-&gt;assbackwards;
}

static req_table_t* req_headers_in(request_rec *r)
{
  req_table_t* t = apr_palloc(r-&gt;pool, sizeof(req_table_t));
  t-&gt;r = r;
  t-&gt;t = r-&gt;headers_in;
  t-&gt;n = &quot;headers_in&quot;;
  return t;
}

static req_table_t* req_headers_out(request_rec *r)
{
  req_table_t* t = apr_palloc(r-&gt;pool, sizeof(req_table_t));
  t-&gt;r = r;
  t-&gt;t = r-&gt;headers_out;
  t-&gt;n = &quot;headers_out&quot;;
  return t;
}

static req_table_t* req_err_headers_out(request_rec *r)
{
  req_table_t* t = apr_palloc(r-&gt;pool, sizeof(req_table_t));
  t-&gt;r = r;
  t-&gt;t = r-&gt;err_headers_out;
  t-&gt;n = &quot;err_headers_out&quot;;
  return t;
}

static req_table_t* req_subprocess_env(request_rec *r)
{
  req_table_t* t = apr_palloc(r-&gt;pool, sizeof(req_table_t));
  t-&gt;r = r;
  t-&gt;t = r-&gt;subprocess_env;
  t-&gt;n = &quot;subprocess_env&quot;;
  return t;
}

static req_table_t* req_notes(request_rec *r)
{
  req_table_t* t = apr_palloc(r-&gt;pool, sizeof(req_table_t));
  t-&gt;r = r;
  t-&gt;t = r-&gt;notes;
  t-&gt;n = &quot;notes&quot;;
  return t;
}

static int req_ssl_is_https_field(request_rec *r)
{
    return ap_lua_ssl_is_https(r-&gt;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-&gt;pool, &quot;%s %s %s %s %s %s&quot;, (opts&amp;OPT_INDEXES) ? &quot;Indexes&quot; : &quot;&quot;, (opts&amp;OPT_INCLUDES) ? &quot;Includes&quot; : &quot;&quot;, (opts&amp;OPT_SYM_LINKS) ? &quot;FollowSymLinks&quot; : &quot;&quot;, (opts&amp;OPT_EXECCGI) ? &quot;ExecCGI&quot; : &quot;&quot;, (opts&amp;OPT_MULTI) ? &quot;MultiViews&quot; : &quot;&quot;, (opts&amp;OPT_ALL) == OPT_ALL ? &quot;All&quot; : &quot;&quot; );
}

static const char* lua_ap_allowoverrides(request_rec* r) 
{
    int opts;
    opts = ap_allow_overrides(r);
    if ( (opts &amp; OR_ALL) == OR_ALL) {
        return &quot;All&quot;;
    }
    else if (opts == OR_NONE) {
        return &quot;None&quot;;
    }
    return apr_psprintf(r-&gt;pool, &quot;%s %s %s %s %s&quot;, (opts &amp; OR_LIMIT) ? &quot;Limit&quot; : &quot;&quot;, (opts &amp; OR_OPTIONS) ? &quot;Options&quot; : &quot;&quot;, (opts &amp; OR_FILEINFO) ? &quot;FileInfo&quot; : &quot;&quot;, (opts &amp; OR_AUTHCFG) ? &quot;AuthCfg&quot; : &quot;&quot;, (opts &amp; OR_INDEXES) ? &quot;Indexes&quot; : &quot;&quot; );
    
}

static int lua_ap_started(request_rec* r) 
{
    return (int)(ap_scoreboard_image-&gt;global-&gt;restart_time / 1000000);
}

static const char* lua_ap_basic_auth_pw(request_rec* r) 
{
    const char* pw = NULL;
    ap_get_basic_auth_pw(r, &amp;pw);
    return pw ? pw : &quot;&quot;;
}

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(&amp;file_info, filename, APR_FINFO_MIN, r-&gt;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(&amp;file, filename, APR_READ, APR_OS_DEFAULT,
                            r-&gt;pool);
        if (rc == APR_SUCCESS) {
            ap_send_fd(file, r, 0, (apr_size_t)file_info.size, &amp;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, &amp;plain_len);
    encoded_len = apr_base64_encode_len(plain_len);
    if (encoded_len) {
        encoded = apr_palloc(r-&gt;pool, encoded_len);
        encoded_len = apr_base64_encode(encoded, plain, plain_len);
        if (encoded_len &gt; 0 &amp;&amp; encoded[encoded_len - 1] == &#039;\0&#039;)
            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, &amp;encoded_len);
    decoded_len = apr_base64_decode_len(encoded);
    if (decoded_len) {
        plain = apr_palloc(r-&gt;pool, decoded_len);
        decoded_len = apr_base64_decode(plain, encoded);
        if (decoded_len &gt; 0 &amp;&amp; plain[decoded_len - 1] == &#039;\0&#039;)
            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, &amp;x);
    plain = apr_pstrdup(r-&gt;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, &amp;x);
    escaped = ap_escape_urlencoded(r-&gt;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, &amp;len);
    result = ap_md5_binary(r-&gt;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-&gt;pool, sizeof(digest) * 2 + 1);
    buffer = lua_tolstring(L, 2, &amp;len);
    apr_sha1_init(&amp;sha1);
    apr_sha1_update(&amp;sha1, buffer, len);
    apr_sha1_final(digest, &amp;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-&gt;pool, lua_tostring(L, 2));
    ctx.alg = luaL_optinteger(L, 3, ALG_APMD5);
    ctx.cost = luaL_optinteger(L, 4, 0);
    ctx.pool = r-&gt;pool;
    ctx.out = apr_pcalloc(r-&gt;pool, MAX_PASSWD_LEN);
    ctx.out_len = MAX_PASSWD_LEN;
    if (mk_password_hash(&amp;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-&gt;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-&gt;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-&gt;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-&gt;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, &amp;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-&gt;pool, r-&gt;pool, &amp;res, expr, NULL);
    if (!err) {
        x = ap_expr_exec(r, &amp;res, &amp;err);
        lua_pushboolean(L, x);
        if (x &lt; 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(&amp;regex, pattern, flags);
    if (rv) {
        lua_pushboolean(L, 0);
        err = apr_palloc(r-&gt;pool, 256);
        ap_regerror(rv, &amp;regex, err, 256);
        lua_pushstring(L, err);
        return 2;
    }

    if (regex.re_nsub &gt; MODLUA_MAX_REG_MATCH) {
        lua_pushboolean(L, 0);
        err = apr_palloc(r-&gt;pool, 64);
        apr_snprintf(err, 64,
                     &quot;regcomp found %d matches; only %d allowed.&quot;,
                     regex.re_nsub, MODLUA_MAX_REG_MATCH);
        lua_pushstring(L, err);
        return 2;
    }

    rv = ap_regexec(&amp;regex, 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 &lt;= regex.re_nsub; i++) {
        lua_pushinteger(L, i);
        if (matches[i].rm_so &gt;= 0 &amp;&amp; matches[i].rm_eo &gt;= 0)
            lua_pushstring(L,
                           apr_pstrndup(r-&gt;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, &quot;connections&quot;);
        lua_pushnumber(L, ps_record-&gt;connections);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;keepalive&quot;);
        lua_pushnumber(L, ps_record-&gt;keep_alive);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;lingering_close&quot;);
        lua_pushnumber(L, ps_record-&gt;lingering_close);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;pid&quot;);
        lua_pushnumber(L, ps_record-&gt;pid);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;suspended&quot;);
        lua_pushnumber(L, ps_record-&gt;suspended);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;wait_io&quot;);
        lua_pushnumber(L, ps_record-&gt;wait_io);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;write_completion&quot;);
        lua_pushnumber(L, ps_record-&gt;write_completion);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;not_accepting&quot;);
        lua_pushnumber(L, ps_record-&gt;not_accepting);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;quiescing&quot;);
        lua_pushnumber(L, ps_record-&gt;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-&gt;pool, sizeof *ws_record);

    ap_copy_scoreboard_worker(ws_record, i, j);
    if (ws_record) {
        lua_newtable(L);

        lua_pushstring(L, &quot;access_count&quot;);
        lua_pushnumber(L, ws_record-&gt;access_count);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;bytes_served&quot;);
        lua_pushnumber(L, (lua_Number) ws_record-&gt;bytes_served);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;client&quot;);
        lua_pushstring(L, ws_record-&gt;client);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;client64&quot;);
        lua_pushstring(L, ws_record-&gt;client64);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;conn_bytes&quot;);
        lua_pushnumber(L, (lua_Number) ws_record-&gt;conn_bytes);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;conn_count&quot;);
        lua_pushnumber(L, ws_record-&gt;conn_count);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;generation&quot;);
        lua_pushnumber(L, ws_record-&gt;generation);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;last_used&quot;);
        lua_pushnumber(L, (lua_Number) ws_record-&gt;last_used);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;pid&quot;);
        lua_pushnumber(L, ws_record-&gt;pid);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;request&quot;);
        lua_pushstring(L, ws_record-&gt;request);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;start_time&quot;);
        lua_pushnumber(L, (lua_Number) ws_record-&gt;start_time);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;status&quot;);
        lua_pushnumber(L, ws_record-&gt;status);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;stop_time&quot;);
        lua_pushnumber(L, (lua_Number) ws_record-&gt;stop_time);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;tid&quot;);

        lua_pushinteger(L, (lua_Integer) ws_record-&gt;tid);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;vhost&quot;);
        lua_pushstring(L, ws_record-&gt;vhost);
        lua_settable(L, -3);
#ifdef HAVE_TIMES
        lua_pushstring(L, &quot;stimes&quot;);
        lua_pushnumber(L, ws_record-&gt;times.tms_stime);
        lua_settable(L, -3);

        lua_pushstring(L, &quot;utimes&quot;);
        lua_pushnumber(L, ws_record-&gt;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-&gt;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 &amp;&amp; mod-&gt;cmds) {
        const command_rec *cmd;
        lua_newtable(L);
        lua_pushstring(L, &quot;commands&quot;);
        lua_newtable(L);
        for (cmd = mod-&gt;cmds; cmd-&gt;name; ++cmd) {
            lua_pushstring(L, cmd-&gt;name);
            lua_pushstring(L, cmd-&gt;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, &quot;.&quot;);
    lua_pushstring(L, ap_runtime_dir_relative(r-&gt;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(&amp;thedir, directory, r-&gt;pool) == APR_SUCCESS) {
        int i = 0;
        lua_newtable(L);
        do {
            status = apr_dir_read(&amp;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(&amp;file_info, filename, wanted, r-&gt;pool) == OK) {
        lua_newtable(L);
        if (wanted &amp; APR_FINFO_MTIME) {
            lua_pushstring(L, &quot;mtime&quot;);
            lua_pushnumber(L, (lua_Number) file_info.mtime);
            lua_settable(L, -3);
        }
        if (wanted &amp; APR_FINFO_ATIME) {
            lua_pushstring(L, &quot;atime&quot;);
            lua_pushnumber(L, (lua_Number) file_info.atime);
            lua_settable(L, -3);
        }
        if (wanted &amp; APR_FINFO_CTIME) {
            lua_pushstring(L, &quot;ctime&quot;);
            lua_pushnumber(L, (lua_Number) file_info.ctime);
            lua_settable(L, -3);
        }
        if (wanted &amp; APR_FINFO_SIZE) {
            lua_pushstring(L, &quot;size&quot;);
            lua_pushnumber(L, (lua_Number) file_info.size);
            lua_settable(L, -3);
        }
        if (wanted &amp; APR_FINFO_TYPE) {
            lua_pushstring(L, &quot;filetype&quot;);
            lua_pushinteger(L, file_info.filetype);
            lua_settable(L, -3);
        }
        if (wanted &amp; APR_FINFO_PROT) {
            lua_pushstring(L, &quot;protection&quot;);
            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] &amp;&amp; ap_loaded_modules[i]-&gt;name; i++) {
        lua_pushinteger(L, i + 1);
        lua_pushstring(L, ap_loaded_modules[i]-&gt;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, &quot;server_executable&quot;);
    lua_pushstring(L, ap_server_argv0);
    lua_settable(L, -3);

    lua_pushstring(L, &quot;server_root&quot;);
    lua_pushstring(L, ap_server_root);
    lua_settable(L, -3);

    lua_pushstring(L, &quot;scoreboard_fname&quot;);
    lua_pushstring(L, ap_scoreboard_fname);
    lua_settable(L, -3);

    lua_pushstring(L, &quot;server_mpm&quot;);
    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 &#039;/&#039; in it (and thus does not prefix &quot;./&quot;)
 * @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-&gt;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-&gt;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 &#039;?&#039; or &#039;*&#039;
 * @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&#039;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&amp;clear headers in r-&gt;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, &quot;Apache2.Request.dispatch&quot;);
    dispatch = lua_touserdata(L, 1);
    lua_pop(L, 1);

    rft = apr_hash_get(dispatch, name, APR_HASH_KEY_STRING);
    if (rft) {
        switch (rft-&gt;type) {
        case APL_REQ_FUNTYPE_TABLE:{
                req_table_t *rs;
                req_field_apr_table_f func = (req_field_apr_table_f)rft-&gt;fun;
                ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01486)
                              &quot;request_rec-&gt;dispatching %s -&gt; apr table&quot;,
                              name);
                rs = (*func)(r);
                ap_lua_push_apr_table(L, rs);
                return 1;
            }

        case APL_REQ_FUNTYPE_LUACFUN:{
                lua_CFunction func = (lua_CFunction)rft-&gt;fun;
                ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01487)
                              &quot;request_rec-&gt;dispatching %s -&gt; lua_CFunction&quot;,
                              name);
                lua_pushcfunction(L, func);
                return 1;
            }
        case APL_REQ_FUNTYPE_STRING:{
                req_field_string_f func = (req_field_string_f)rft-&gt;fun;
                char *rs;
                ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01488)
                              &quot;request_rec-&gt;dispatching %s -&gt; string&quot;, 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-&gt;fun;
                int rs;
                ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01489)
                              &quot;request_rec-&gt;dispatching %s -&gt; int&quot;, 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-&gt;fun;
                int rs;
                ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01490)
                              &quot;request_rec-&gt;dispatching %s -&gt; boolean&quot;, name);
                rs = (*func) (r);
                lua_pushboolean(L, rs);
                return 1;
            }
        }
    }

    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01491) &quot;nothing for %s&quot;, 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, &amp;dbg);
    lua_getinfo(L, &quot;Sl&quot;, &amp;dbg);

    msg = luaL_checkstring(L, 2);
    /* Intentional no APLOGNO */
    ap_log_rerror(dbg.source, dbg.currentline, APLOG_MODULE_INDEX, level, 0,
                  r, &quot;%s&quot;, 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-&gt;pool, &quot;lua_ivm_&quot;, 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 **)&amp;object, raw_key, pool);
    if (object) {
        if (object-&gt;type == LUA_TBOOLEAN) lua_pushboolean(L, (int) object-&gt;number);
        else if (object-&gt;type == LUA_TNUMBER) lua_pushnumber(L, object-&gt;number);
        else if (object-&gt;type == LUA_TSTRING) lua_pushlstring(L, object-&gt;vb.buf, object-&gt;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-&gt;pool, &quot;lua_ivm_&quot;, 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 **)&amp;object, raw_key, pool);
    if (!object) {
        object = apr_pcalloc(pool, sizeof(lua_ivm_object));
        ap_varbuf_init(pool, &amp;object-&gt;vb, 2);
        object-&gt;size = 1;
        object-&gt;vb_size = 1;
    }
    object-&gt;type = lua_type(L, 3);
    if (object-&gt;type == LUA_TNUMBER) object-&gt;number = lua_tonumber(L, 3);
    else if (object-&gt;type == LUA_TBOOLEAN) object-&gt;number = lua_tonumber(L, 3);
    else if (object-&gt;type == LUA_TSTRING) {
        value = lua_tolstring(L, 3, &amp;str_len);
        str_len++; /* add trailing \0 */
        if ( str_len &gt; object-&gt;vb_size) {
            ap_varbuf_grow(&amp;object-&gt;vb, str_len);
            object-&gt;vb_size = str_len;
        }
        object-&gt;size = str_len-1;
        memset(object-&gt;vb.buf, 0, str_len);
        memcpy(object-&gt;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, &amp;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 = &quot;&quot;, *domain = &quot;&quot;;
    const char *strexpires = &quot;&quot;, *strdomain = &quot;&quot;, *strpath = &quot;&quot;;
    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 &gt;= 2.4.8 method: */
    if (lua_istable(L, 2)) {
         
        /* key */
        lua_pushstring(L, &quot;key&quot;);
        lua_gettable(L, -2);
        key = luaL_checkstring(L, -1);
        lua_pop(L, 1);
        
        /* value */
        lua_pushstring(L, &quot;value&quot;);
        lua_gettable(L, -2);
        value = luaL_checkstring(L, -1);
        lua_pop(L, 1);
        
        /* expiry */
        lua_pushstring(L, &quot;expires&quot;);
        lua_gettable(L, -2);
        expires = (int)luaL_optinteger(L, -1, 0);
        lua_pop(L, 1);
        
        /* secure */
        lua_pushstring(L, &quot;secure&quot;);
        lua_gettable(L, -2);
        if (lua_isboolean(L, -1)) {
            secure = lua_toboolean(L, -1);
        }
        lua_pop(L, 1);
        
        /* httponly */
        lua_pushstring(L, &quot;httponly&quot;);
        lua_gettable(L, -2);
        if (lua_isboolean(L, -1)) {
            httponly = lua_toboolean(L, -1);
        }
        lua_pop(L, 1);
        
        /* path */
        lua_pushstring(L, &quot;path&quot;);
        lua_gettable(L, -2);
        path = luaL_optstring(L, -1, &quot;/&quot;);
        lua_pop(L, 1);
        
        /* domain */
        lua_pushstring(L, &quot;domain&quot;);
        lua_gettable(L, -2);
        domain = luaL_optstring(L, -1, &quot;&quot;);
        lua_pop(L, 1);        
    }
    /* Old &lt;= 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 &gt; 0) {
        rv = apr_rfc822_date(cdate, apr_time_from_sec(expires));
        if (rv == APR_SUCCESS) {
            strexpires = apr_psprintf(r-&gt;pool, &quot;Expires=%s;&quot;, cdate);
        }
    }
    
    /* Create path segment */
    if (path != NULL &amp;&amp; strlen(path) &gt; 0) {
        strpath = apr_psprintf(r-&gt;pool, &quot;Path=%s;&quot;, path);
    }
    
    /* Create domain segment */
    if (domain != NULL &amp;&amp; strlen(domain) &gt; 0) {
        /* Domain does NOT like quotes in most browsers, so let&#039;s avoid that */
        strdomain = apr_psprintf(r-&gt;pool, &quot;Domain=%s;&quot;, domain);
    }
    
    /* URL-encode key/value */
    value = ap_escape_urlencoded(r-&gt;pool, value);
    key = ap_escape_urlencoded(r-&gt;pool, key);
    
    /* Create the header */
    out = apr_psprintf(r-&gt;pool, &quot;%s=%s; %s %s %s %s %s&quot;, key, value, 
            secure ? &quot;Secure;&quot; : &quot;&quot;, 
            expires ? strexpires : &quot;&quot;, 
            httponly ? &quot;HttpOnly;&quot; : &quot;&quot;, 
            *strdomain ? strdomain : &quot;&quot;, 
            *strpath ? strpath : &quot;&quot;);
    
    apr_table_add(r-&gt;err_headers_out, &quot;Set-Cookie&quot;, out);
    return 0;
}

static apr_uint64_t ap_ntoh64(const apr_uint64_t *input)
{
    apr_uint64_t rval;
    unsigned char *data = (unsigned char *)&amp;rval;
    if (APR_IS_BIGENDIAN) {
        return *input;
    }
    
    data[0] = *input &gt;&gt; 56;
    data[1] = *input &gt;&gt; 48;
    data[2] = *input &gt;&gt; 40;
    data[3] = *input &gt;&gt; 32;
    data[4] = *input &gt;&gt; 24;
    data[5] = *input &gt;&gt; 16;
    data[6] = *input &gt;&gt; 8;
    data[7] = *input &gt;&gt; 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-&gt;headers_in, &quot;Sec-WebSocket-Key&quot;);
    if (key != NULL) {
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(03011) 
                      &quot;Websocket: Got websocket key: %s&quot;, key);
        key = apr_pstrcat(r-&gt;pool, key, &quot;258EAFA5-E914-47DA-95CA-C5AB0DC85B11&quot;, 
                NULL);
        apr_sha1_init(&amp;sha1);
        apr_sha1_update(&amp;sha1, key, strlen(key));
        apr_sha1_final(digest, &amp;sha1);
        encoded_len = apr_base64_encode_len(APR_SHA1_DIGESTSIZE);
        if (encoded_len) {
            encoded = apr_palloc(r-&gt;pool, encoded_len);
            encoded_len = apr_base64_encode(encoded, (char*) digest, APR_SHA1_DIGESTSIZE);
            r-&gt;status = 101;
            apr_table_setn(r-&gt;headers_out, &quot;Upgrade&quot;, &quot;websocket&quot;);
            apr_table_setn(r-&gt;headers_out, &quot;Connection&quot;, &quot;Upgrade&quot;);
            apr_table_setn(r-&gt;headers_out, &quot;Sec-WebSocket-Accept&quot;, encoded);
            
            /* Trick httpd into NOT using the chunked filter, IMPORTANT!!!111*/
            apr_table_setn(r-&gt;headers_out, &quot;Transfer-Encoding&quot;, &quot;chunked&quot;);
            
            r-&gt;clength = 0;
            r-&gt;bytes_sent = 0;
            r-&gt;read_chunked = 0;
            ap_rflush(r);
            ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(03012) 
                          &quot;Websocket: Upgraded from HTTP to Websocket&quot;);
            lua_pushboolean(L, 1);
            return 1;
        }
    }
    ap_log_rerror(APLOG_MARK, APLOG_NOTICE, 0, r, APLOGNO(02666)
                  &quot;Websocket: Upgrade from HTTP to Websocket failed&quot;);
    return 0;
}

static apr_status_t lua_websocket_readbytes(conn_rec* c,
                                            apr_bucket_brigade *brigade,
                                            char* buffer, apr_off_t len)
{
    apr_size_t delivered;
    apr_status_t rv;

    rv = ap_get_brigade(c-&gt;input_filters, brigade, AP_MODE_READBYTES, 
            APR_BLOCK_READ, len);
    if (rv == APR_SUCCESS) {
        delivered = len;
        rv = apr_brigade_flatten(brigade, buffer, &amp;delivered);
        if ((rv == APR_SUCCESS) &amp;&amp; (delivered &lt; len)) {
            rv = APR_INCOMPLETE;
        }
    }
    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-&gt;connection-&gt;pool, 
            r-&gt;connection-&gt;bucket_alloc);
    rv = ap_get_brigade(r-&gt;connection-&gt;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_status_t rv;
    int do_read = 1;
    int n = 0;
    apr_size_t plen = 0;
    unsigned short payload_short = 0;
    apr_uint64_t payload_long = 0;
    unsigned char *mask_bytes;
    char byte;
    apr_bucket_brigade *brigade;
    conn_rec* c;

    request_rec *r = ap_lua_check_request_rec(L, 1);
    c = r-&gt;connection;

    mask_bytes = apr_pcalloc(r-&gt;pool, 4);

    brigade = apr_brigade_create(r-&gt;pool, c-&gt;bucket_alloc);

    while (do_read) {
        do_read = 0;
        /* Get opcode and FIN bit */
        rv = lua_websocket_readbytes(c, brigade, &amp;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 &gt;&gt; (CHAR_BIT - 1);
            /* opcode is the last four bits (there&#039;s 3 reserved bits we don&#039;t care about) */
            opcode = ubyte &amp; 0xf;

            /* Get the payload length and mask bit */
            rv = lua_websocket_readbytes(c, brigade, &amp;byte, 1);
            if (rv == APR_SUCCESS) {
                ubyte = (unsigned char)byte;
                /* Mask is the first bit */
                mask = ubyte &gt;&gt; (CHAR_BIT - 1);
                /* Payload is the last 7 bits */
                payload = ubyte &amp; 0x7f;
                plen = payload;

                /* Extended payload? */
                if (payload == 126) {
                    rv = lua_websocket_readbytes(c, brigade,
                                                 (char*) &amp;payload_short, 2);

                    if (rv != APR_SUCCESS) {
                        return 0;
                    }

                    plen = ntohs(payload_short);
                }
                /* Super duper extended payload? */
                if (payload == 127) {
                    rv = lua_websocket_readbytes(c, brigade,
                                                 (char*) &amp;payload_long, 8);

                    if (rv != APR_SUCCESS) {
                        return 0;
                    }

                    plen = ap_ntoh64(&amp;payload_long);
                }
                ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(03210)
                              &quot;Websocket: Reading %&quot; APR_SIZE_T_FMT &quot; (%s) bytes, masking is %s. %s&quot;, 
                              plen,
                              (payload &gt;= 126) ? &quot;extra payload&quot; : &quot;no extra payload&quot;, 
                              mask ? &quot;on&quot; : &quot;off&quot;, 
                              fin ? &quot;This is a final frame&quot; : &quot;more to follow&quot;);
                if (mask) {
                    rv = lua_websocket_readbytes(c, brigade,
                                                 (char*) mask_bytes, 4);

                    if (rv != APR_SUCCESS) {
                        return 0;
                    }
                }
                if (plen &lt; (HUGE_STRING_LEN*1024) &amp;&amp; plen &gt; 0) {
                    apr_size_t remaining = plen;
                    char *buffer = apr_palloc(r-&gt;pool, plen+1);
                    buffer[plen] = 0;

                    rv = lua_websocket_readbytes(c, brigade, buffer, remaining);

                    if (rv != APR_SUCCESS) {
                        return 0;
                    }

                    ap_log_rerror(APLOG_MARK, APLOG_TRACE1, 0, r,
                                  &quot;Websocket: Frame contained %&quot; APR_SIZE_T_FMT \
                                  &quot; bytes, pushed to Lua stack&quot;, remaining);
                    if (mask) {
                        for (n = 0; n &lt; 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];
                    apr_bucket *b;

                    frame[0] = 0x8A;
                    frame[1] = 0;

                    /* Pong! */
                    b = apr_bucket_transient_create(frame, 2, c-&gt;bucket_alloc);
                    APR_BRIGADE_INSERT_TAIL(brigade, b);

                    rv = ap_pass_brigade(c-&gt;output_filters, brigade);
                    apr_brigade_cleanup(brigade);

                    if (rv != APR_SUCCESS) {
                        return 0;
                    }

                    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, &amp;len);
    
    if (raw != 1) {
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(03013) 
                      &quot;Websocket: Writing framed message to client&quot;);
        
        prelude = 0x81; /* text frame, FIN */
        ap_rputc(prelude, r);
        if (len &lt; 126) {
            ap_rputc(len, r);
        } 
        else if (len &lt; 65535) {
            apr_uint16_t slen = len;
            ap_rputc(126, r); 
            slen = htons(slen);
            ap_rwrite((char*) &amp;slen, 2, r);
        }
        else {
            apr_uint64_t llen = len;
            ap_rputc(127, r);
            llen = ap_ntoh64(&amp;llen); /* ntoh doubles as hton */
            ap_rwrite((char*) &amp;llen, 8, r);
        }
    }
    else {
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(03014) 
                      &quot;Websocket: Writing raw message to client&quot;);
    }
    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-&gt;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-&gt;output_filters = NULL;
    r-&gt;connection-&gt;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-&gt;connection);
    
    /* Send a header that says: PING. */
    prelude[0] = 0x89; /* ping  opcode */
    prelude[1] = 0;
    plen = 2;
    apr_socket_send(sock, prelude, &amp;plen);
    
    
    /* Get opcode and FIN bit from pong */
    plen = 2;
    rv = apr_socket_recv(sock, prelude, &amp;plen);
    if (rv == APR_SUCCESS) {
        unsigned char opcode = prelude[0];
        unsigned char len = prelude[1];
        unsigned char mask = len &gt;&gt; 7;
        if (mask) len -= 128;
        plen = len;
        ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(03015) 
                      &quot;Websocket: Got PONG opcode: %x&quot;, opcode);
        if (opcode == 0x8A) {
            lua_pushboolean(L, 1);
        }
        else {
            lua_pushboolean(L, 0);
        }
        if (plen &gt; 0) {
            ap_log_rerror(APLOG_MARK, APLOG_TRACE1, 0, r, 
                          &quot;Websocket: Reading %&quot; APR_SIZE_T_FMT &quot; bytes of PONG&quot;, plen);
            return 1;
        }
        if (mask) {
            plen = 2;
            apr_socket_recv(sock, prelude, &amp;plen);
            plen = 2;
            apr_socket_recv(sock, prelude, &amp;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(&quot;ap_auth_type&quot;, key)) {
        const char *value = luaL_checkstring(L, 3);
        r-&gt;ap_auth_type = apr_pstrdup(r-&gt;pool, value);
        return 0;
    }

    if (0 == strcmp(&quot;args&quot;, key)) {
        const char *value = luaL_checkstring(L, 3);
        r-&gt;args = apr_pstrdup(r-&gt;pool, value);
        return 0;
    }

    if (0 == strcmp(&quot;content_type&quot;, key)) {
        const char *value = luaL_checkstring(L, 3);
        ap_set_content_type(r, apr_pstrdup(r-&gt;pool, value));
        return 0;
    }

    if (0 == strcmp(&quot;filename&quot;, key)) {
        const char *value = luaL_checkstring(L, 3);
        r-&gt;filename = apr_pstrdup(r-&gt;pool, value);
        return 0;
    }

    if (0 == strcmp(&quot;handler&quot;, key)) {
        const char *value = luaL_checkstring(L, 3);
        r-&gt;handler = apr_pstrdup(r-&gt;pool, value);
        return 0;
    }

    if (0 == strcmp(&quot;proxyreq&quot;, key)) {
        int value = luaL_checkinteger(L, 3);
        r-&gt;proxyreq = value;
        return 0;
    }

    if (0 == strcmp(&quot;status&quot;, key)) {
        int code = luaL_checkinteger(L, 3);
        r-&gt;status = code;
        return 0;
    }

    if (0 == strcmp(&quot;uri&quot;, key)) {
        const char *value = luaL_checkstring(L, 3);
        r-&gt;uri = apr_pstrdup(r-&gt;pool, value);
        return 0;
    }

    if (0 == strcmp(&quot;user&quot;, key)) {
        const char *value = luaL_checkstring(L, 3);
        r-&gt;user = apr_pstrdup(r-&gt;pool, value);
        return 0;
    }

    lua_pushstring(L,
                   apr_psprintf(r-&gt;pool,
                                &quot;Property [%s] may not be set on a request_rec&quot;,
                                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-&gt;next) {
        x++;
        lua_pushnumber(L, x);
        lua_newtable(L);
        value = apr_psprintf(r-&gt;pool, &quot;%s %s&quot;, cfg-&gt;directive, cfg-&gt;args);
        lua_pushstring(L, &quot;directive&quot;);
        lua_pushstring(L, value);
        lua_settable(L, -3);
        lua_pushstring(L, &quot;file&quot;);
        lua_pushstring(L, cfg-&gt;filename);
        lua_settable(L, -3);
        lua_pushstring(L, &quot;line&quot;);
        lua_pushnumber(L, cfg-&gt;line_num);
        lua_settable(L, -3);
        if (cfg-&gt;first_child) {
            lua_pushstring(L, &quot;children&quot;);
            read_cfg_tree(L, r, cfg-&gt;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-&gt;next) {
        if (ap_strcasestr(dir-&gt;directive, &quot;&lt;virtualhost&quot;) &amp;&amp; dir-&gt;first_child) {
            for (subdir = dir-&gt;first_child; subdir; subdir = subdir-&gt;next) {
                if (ap_strcasecmp_match(subdir-&gt;directive, &quot;servername&quot;) &amp;&amp;
                        !ap_strcasecmp_match(r-&gt;hostname, subdir-&gt;args)) {
                    read_cfg_tree(L, r, dir-&gt;first_child);
                    return 1;
                }
                if (ap_strcasecmp_match(subdir-&gt;directive, &quot;serveralias&quot;) &amp;&amp;
                        !ap_strcasecmp_match(r-&gt;hostname, subdir-&gt;args)) {
                    read_cfg_tree(L, r, dir-&gt;first_child);
                    return 1;
                }
            }
        }
    }     
    return 0;
}



static const struct luaL_Reg request_methods[] = {
    {&quot;__index&quot;, req_dispatch},
    {&quot;__newindex&quot;, req_newindex},
    /*   {&quot;__newindex&quot;, 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 : &quot;&quot;;
}

static const char* lua_ap_get_server_name(request_rec* r)
{
    const char *name;
    name = ap_get_server_name(r);
    return name ? name : &quot;localhost&quot;;
}




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-&gt;fun = fun;
    rft-&gt;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, &quot;puts&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_puts, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;write&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_write, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;document_root&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_document_root, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;context_prefix&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_context_prefix, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;context_document_root&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_context_document_root, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;parseargs&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_parseargs, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;parsebody&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_parsebody, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;debug&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_debug, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;info&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_info, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;notice&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_notice, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;warn&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_warn, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;err&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_err, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;crit&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_crit, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;alert&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_alert, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;emerg&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_emerg, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;trace1&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_trace1, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;trace2&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_trace2, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;trace3&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_trace3, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;trace4&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_trace4, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;trace5&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_trace5, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;trace6&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_trace6, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;trace7&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_trace7, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;trace8&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_trace8, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;add_output_filter&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_add_output_filter, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;construct_url&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_construct_url, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;escape_html&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_escape_html, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;ssl_var_lookup&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_ssl_var_lookup, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;is_https&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_ssl_is_https_field, APL_REQ_FUNTYPE_BOOLEAN, p));
    apr_hash_set(dispatch, &quot;assbackwards&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_assbackwards_field, APL_REQ_FUNTYPE_BOOLEAN, p));
    apr_hash_set(dispatch, &quot;status&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_status_field, APL_REQ_FUNTYPE_INT, p));
    apr_hash_set(dispatch, &quot;protocol&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_protocol_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;range&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_range_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;content_type&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_content_type_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;content_encoding&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_content_encoding_field, APL_REQ_FUNTYPE_STRING,
                         p));
    apr_hash_set(dispatch, &quot;ap_auth_type&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_ap_auth_type_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;unparsed_uri&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_unparsed_uri_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;user&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_user_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;filename&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_filename_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;canonical_filename&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_canonical_filename_field,
                         APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;path_info&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_path_info_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;args&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_args_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;handler&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_handler_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;hostname&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_hostname_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;uri&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_uri_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;the_request&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_the_request_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;log_id&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_log_id_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;useragent_ip&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_useragent_ip_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;method&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_method_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;proxyreq&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_proxyreq_field, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;headers_in&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_headers_in, APL_REQ_FUNTYPE_TABLE, p));
    apr_hash_set(dispatch, &quot;headers_in_table&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_headers_in_table, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;headers_out&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_headers_out, APL_REQ_FUNTYPE_TABLE, p));
    apr_hash_set(dispatch, &quot;headers_out_table&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_headers_out_table, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;err_headers_out&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_err_headers_out, APL_REQ_FUNTYPE_TABLE, p));
    apr_hash_set(dispatch, &quot;err_headers_out_table&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_err_headers_out_table, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;notes&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_notes, APL_REQ_FUNTYPE_TABLE, p));
    apr_hash_set(dispatch, &quot;notes_table&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_notes_table, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;subprocess_env&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_subprocess_env, APL_REQ_FUNTYPE_TABLE, p));
    apr_hash_set(dispatch, &quot;subprocess_env_table&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_subprocess_env_table, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;flush&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_rflush, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;port&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_ap_get_server_port, APL_REQ_FUNTYPE_INT, p));
    apr_hash_set(dispatch, &quot;banner&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;ap_get_server_banner, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;options&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_options, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;allowoverrides&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_allowoverrides, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;started&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_started, APL_REQ_FUNTYPE_INT, p));
    apr_hash_set(dispatch, &quot;basic_auth_pw&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_basic_auth_pw, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;limit_req_body&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_limit_req_body, APL_REQ_FUNTYPE_INT, p));
    apr_hash_set(dispatch, &quot;server_built&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;ap_get_server_built, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;is_initial_req&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_is_initial_req, APL_REQ_FUNTYPE_BOOLEAN, p));
    apr_hash_set(dispatch, &quot;remaining&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;req_remaining_field, APL_REQ_FUNTYPE_INT, p));
    apr_hash_set(dispatch, &quot;some_auth_required&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_some_auth_required, APL_REQ_FUNTYPE_BOOLEAN, p));
    apr_hash_set(dispatch, &quot;server_name&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_get_server_name, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;auth_name&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_auth_name, APL_REQ_FUNTYPE_STRING, p));
    apr_hash_set(dispatch, &quot;sendfile&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_sendfile, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;dbacquire&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_db_acquire, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;stat&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_stat, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;get_direntries&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_getdir, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;regex&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_regex, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;usleep&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_usleep, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;base64_encode&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_apr_b64encode, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;base64_decode&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_apr_b64decode, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;md5&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_apr_md5, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;sha1&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_apr_sha1, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;htpassword&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_apr_htpassword, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;touch&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_apr_touch, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;mkdir&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_apr_mkdir, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;mkrdir&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_apr_mkrdir, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;rmdir&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_apr_rmdir, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;date_parse_rfc&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_apr_date_parse_rfc, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;escape&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_escape, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;unescape&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_unescape, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;mpm_query&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_mpm_query, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;expr&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_expr, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;scoreboard_process&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_scoreboard_process, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;scoreboard_worker&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_scoreboard_worker, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;clock&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_clock, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;requestbody&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_requestbody, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;add_input_filter&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_add_input_filter, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;module_info&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_module_info, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;loaded_modules&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_loaded_modules, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;runtime_dir_relative&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_runtime_dir_relative, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;server_info&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_server_info, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;set_document_root&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_set_document_root, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;set_context_info&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_set_context_info, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;os_escape_path&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_os_escape_path, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;escape_logitem&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_escape_logitem, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;strcmp_match&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_strcmp_match, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;set_keepalive&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_set_keepalive, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;make_etag&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_make_etag, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;send_interim_response&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_send_interim_response, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;custom_response&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_custom_response, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;exists_config_define&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_exists_config_define, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;state_query&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_state_query, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;get_server_name_for_url&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_get_server_name_for_url, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;ivm_get&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ivm_get, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;ivm_set&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ivm_set, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;getcookie&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_get_cookie, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;setcookie&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_set_cookie, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;wsupgrade&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_websocket_greet, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;wsread&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_websocket_read, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;wspeek&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_websocket_peek, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;wswrite&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_websocket_write, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;wsclose&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_websocket_close, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;wsping&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_websocket_ping, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;config&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_get_config, APL_REQ_FUNTYPE_LUACFUN, p));
    apr_hash_set(dispatch, &quot;activeconfig&quot;, APR_HASH_KEY_STRING,
                 makefun(&amp;lua_ap_get_active_config, APL_REQ_FUNTYPE_LUACFUN, p));
    lua_pushlightuserdata(L, dispatch);
    lua_setfield(L, LUA_REGISTRYINDEX, &quot;Apache2.Request.dispatch&quot;);

    luaL_newmetatable(L, &quot;Apache2.Request&quot;);     /* [metatable] */
    lua_pushvalue(L, -1);

    lua_setfield(L, -2, &quot;__index&quot;);
    luaL_setfuncs_compat(L, request_methods);    /* [metatable] */

    lua_pop(L, 2);

    luaL_newmetatable(L, &quot;Apache2.Connection&quot;);  /* [metatable] */
    lua_pushvalue(L, -1);

    lua_setfield(L, -2, &quot;__index&quot;);
    luaL_setfuncs_compat(L, connection_methods); /* [metatable] */

    lua_pop(L, 2);

    luaL_newmetatable(L, &quot;Apache2.Server&quot;);      /* [metatable] */
    lua_pushvalue(L, -1);

    lua_setfield(L, -2, &quot;__index&quot;);
    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, &quot;Apache2.Connection&quot;);
    lua_setmetatable(L, -2);
    luaL_getmetatable(L, &quot;Apache2.Connection&quot;);

    t = apr_pcalloc(c-&gt;pool, sizeof(req_table_t));
    t-&gt;t = c-&gt;notes;
    t-&gt;r = NULL;
    t-&gt;n = &quot;notes&quot;;
    ap_lua_push_apr_table(L, t);
    lua_setfield(L, -2, &quot;notes&quot;);

    lua_pushstring(L, c-&gt;client_ip);
    lua_setfield(L, -2, &quot;client_ip&quot;);

    lua_pop(L, 1);
}


void ap_lua_push_server(lua_State *L, server_rec *s)
{
    lua_boxpointer(L, s);
    luaL_getmetatable(L, &quot;Apache2.Server&quot;);
    lua_setmetatable(L, -2);
    luaL_getmetatable(L, &quot;Apache2.Server&quot;);

    lua_pushstring(L, s-&gt;server_hostname);
    lua_setfield(L, -2, &quot;server_hostname&quot;);

    lua_pop(L, 1);
}

void ap_lua_push_request(lua_State *L, request_rec *r)
{
    lua_boxpointer(L, r);
    luaL_getmetatable(L, &quot;Apache2.Request&quot;);
    lua_setmetatable(L, -2);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fhttpd-2.4.63%2Fmodules%2Flua'>🔙 Back</a></p>