passenger 4.0.59 → 4.0.60

data/packaging/debian/debian_specs/nginx/modules/nginx-lua/src/ngx_http_lua_util.h

@@ -0,0 +1,423 @@
+
+/*
+ * Copyright (C) Xiaozhe Wang (chaoslawful)
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef _NGX_HTTP_LUA_UTIL_H_INCLUDED_
+#define _NGX_HTTP_LUA_UTIL_H_INCLUDED_
+
+
+#include "ngx_http_lua_common.h"
+
+
+#ifndef NGX_UNESCAPE_URI_COMPONENT
+#define NGX_UNESCAPE_URI_COMPONENT  0
+#endif
+
+
+#ifndef NGX_LUA_NO_FFI_API
+typedef struct {
+    int          len;
+    /* this padding hole on 64-bit systems is expected */
+    u_char      *data;
+} ngx_http_lua_ffi_str_t;
+
+
+typedef struct {
+    ngx_http_lua_ffi_str_t   key;
+    ngx_http_lua_ffi_str_t   value;
+} ngx_http_lua_ffi_table_elt_t;
+#endif /* NGX_LUA_NO_FFI_API */
+
+
+/* char whose address we use as the key in Lua vm registry for
+ * user code cache table */
+extern char ngx_http_lua_code_cache_key;
+
+
+/* key in Lua vm registry for all the "ngx.ctx" tables */
+#define ngx_http_lua_ctx_tables_key  "ngx_lua_ctx_tables"
+
+
+/* char whose address we use as the key in Lua vm registry for
+ * regex cache table  */
+extern char ngx_http_lua_regex_cache_key;
+
+/* char whose address we use as the key in Lua vm registry for
+ * socket connection pool table */
+extern char ngx_http_lua_socket_pool_key;
+
+/* char whose address we use as the key for the coroutine parent relationship */
+extern char ngx_http_lua_coroutine_parents_key;
+
+/* coroutine anchoring table key in Lua VM registry */
+extern char ngx_http_lua_coroutines_key;
+
+/* key to the metatable for ngx.req.get_headers() and ngx.resp.get_headers() */
+extern char ngx_http_lua_headers_metatable_key;
+
+
+#ifndef ngx_str_set
+#define ngx_str_set(str, text)                                               \
+    (str)->len = sizeof(text) - 1; (str)->data = (u_char *) text
+#endif
+
+
+#ifndef NGX_HTTP_SWITCHING_PROTOCOLS
+#define NGX_HTTP_SWITCHING_PROTOCOLS 101
+#endif
+
+
+#if defined(nginx_version) && nginx_version < 1000000
+#define ngx_memmove(dst, src, n)   (void) memmove(dst, src, n)
+#endif
+
+
+#define ngx_http_lua_context_name(c)                                         \
+    ((c) == NGX_HTTP_LUA_CONTEXT_SET ? "set_by_lua*"                         \
+     : (c) == NGX_HTTP_LUA_CONTEXT_REWRITE ? "rewrite_by_lua*"               \
+     : (c) == NGX_HTTP_LUA_CONTEXT_ACCESS ? "access_by_lua*"                 \
+     : (c) == NGX_HTTP_LUA_CONTEXT_CONTENT ? "content_by_lua*"               \
+     : (c) == NGX_HTTP_LUA_CONTEXT_LOG ? "log_by_lua*"                       \
+     : (c) == NGX_HTTP_LUA_CONTEXT_HEADER_FILTER ? "header_filter_by_lua*"   \
+     : (c) == NGX_HTTP_LUA_CONTEXT_TIMER ? "ngx.timer"                       \
+     : (c) == NGX_HTTP_LUA_CONTEXT_INIT_WORKER ? "init_worker_by_lua*"       \
+     : "(unknown)")
+
+
+#define ngx_http_lua_check_context(L, ctx, flags)                            \
+    if (!((ctx)->context & (flags))) {                                       \
+        return luaL_error(L, "API disabled in the context of %s",            \
+                          ngx_http_lua_context_name((ctx)->context));        \
+    }
+
+
+#ifndef NGX_LUA_NO_FFI_API
+static ngx_inline ngx_int_t
+ngx_http_lua_ffi_check_context(ngx_http_lua_ctx_t *ctx, unsigned flags,
+    u_char *err, size_t *errlen)
+{
+    if (!(ctx->context & flags)) {
+        *errlen = ngx_snprintf(err, *errlen,
+                               "API disabled in the context of %s",
+                               ngx_http_lua_context_name((ctx)->context))
+                  - err;
+
+        return NGX_DECLINED;
+    }
+
+    return NGX_OK;
+}
+#endif
+
+
+#define ngx_http_lua_check_fake_request(L, r)                                \
+    if ((r)->connection->fd == -1) {                                         \
+        return luaL_error(L, "API disabled in the current context");         \
+    }
+
+
+#define ngx_http_lua_check_fake_request2(L, r, ctx)                          \
+    if ((r)->connection->fd == -1) {                                         \
+        return luaL_error(L, "API disabled in the context of %s",            \
+                          ngx_http_lua_context_name((ctx)->context));        \
+    }
+
+
+lua_State * ngx_http_lua_init_vm(lua_State *parent_vm, ngx_cycle_t *cycle,
+    ngx_pool_t *pool, ngx_http_lua_main_conf_t *lmcf, ngx_log_t *log,
+    ngx_pool_cleanup_t **pcln);
+
+lua_State * ngx_http_lua_new_thread(ngx_http_request_t *r, lua_State *l,
+    int *ref);
+
+u_char * ngx_http_lua_rebase_path(ngx_pool_t *pool, u_char *src, size_t len);
+
+ngx_int_t ngx_http_lua_send_header_if_needed(ngx_http_request_t *r,
+    ngx_http_lua_ctx_t *ctx);
+
+ngx_int_t ngx_http_lua_send_chain_link(ngx_http_request_t *r,
+    ngx_http_lua_ctx_t *ctx, ngx_chain_t *cl);
+
+void ngx_http_lua_discard_bufs(ngx_pool_t *pool, ngx_chain_t *in);
+
+ngx_int_t ngx_http_lua_add_copy_chain(ngx_http_request_t *r,
+    ngx_http_lua_ctx_t *ctx, ngx_chain_t ***plast, ngx_chain_t *in,
+    ngx_int_t *eof);
+
+void ngx_http_lua_reset_ctx(ngx_http_request_t *r, lua_State *L,
+    ngx_http_lua_ctx_t *ctx);
+
+void ngx_http_lua_generic_phase_post_read(ngx_http_request_t *r);
+
+void ngx_http_lua_request_cleanup(ngx_http_lua_ctx_t *ctx, int foricible);
+
+void ngx_http_lua_request_cleanup_handler(void *data);
+
+ngx_int_t ngx_http_lua_run_thread(lua_State *L, ngx_http_request_t *r,
+    ngx_http_lua_ctx_t *ctx, volatile int nret);
+
+ngx_int_t ngx_http_lua_wev_handler(ngx_http_request_t *r);
+
+u_char * ngx_http_lua_digest_hex(u_char *dest, const u_char *buf,
+    int buf_len);
+
+void ngx_http_lua_set_multi_value_table(lua_State *L, int index);
+
+void ngx_http_lua_unescape_uri(u_char **dst, u_char **src, size_t size,
+    ngx_uint_t type);
+
+uintptr_t ngx_http_lua_escape_uri(u_char *dst, u_char *src,
+    size_t size, ngx_uint_t type);
+
+void ngx_http_lua_inject_req_api(ngx_log_t *log, lua_State *L);
+
+void ngx_http_lua_process_args_option(ngx_http_request_t *r,
+    lua_State *L, int table, ngx_str_t *args);
+
+ngx_int_t ngx_http_lua_open_and_stat_file(u_char *name,
+    ngx_open_file_info_t *of, ngx_log_t *log);
+
+ngx_chain_t * ngx_http_lua_chain_get_free_buf(ngx_log_t *log, ngx_pool_t *p,
+    ngx_chain_t **free, size_t len);
+
+void ngx_http_lua_create_new_globals_table(lua_State *L, int narr, int nrec);
+
+int ngx_http_lua_traceback(lua_State *L);
+
+ngx_http_lua_co_ctx_t * ngx_http_lua_get_co_ctx(lua_State *L,
+    ngx_http_lua_ctx_t *ctx);
+
+ngx_http_lua_co_ctx_t * ngx_http_lua_create_co_ctx(ngx_http_request_t *r,
+    ngx_http_lua_ctx_t *ctx);
+
+ngx_int_t ngx_http_lua_run_posted_threads(ngx_connection_t *c, lua_State *L,
+    ngx_http_request_t *r, ngx_http_lua_ctx_t *ctx);
+
+ngx_int_t ngx_http_lua_post_thread(ngx_http_request_t *r,
+    ngx_http_lua_ctx_t *ctx, ngx_http_lua_co_ctx_t *coctx);
+
+void ngx_http_lua_del_thread(ngx_http_request_t *r, lua_State *L,
+    ngx_http_lua_ctx_t *ctx, ngx_http_lua_co_ctx_t *coctx);
+
+void ngx_http_lua_rd_check_broken_connection(ngx_http_request_t *r);
+
+ngx_int_t ngx_http_lua_test_expect(ngx_http_request_t *r);
+
+ngx_int_t ngx_http_lua_check_broken_connection(ngx_http_request_t *r,
+    ngx_event_t *ev);
+
+void ngx_http_lua_finalize_request(ngx_http_request_t *r, ngx_int_t rc);
+
+void ngx_http_lua_finalize_fake_request(ngx_http_request_t *r,
+    ngx_int_t rc);
+
+void ngx_http_lua_close_fake_connection(ngx_connection_t *c);
+
+void ngx_http_lua_release_ngx_ctx_table(ngx_log_t *log, lua_State *L,
+    ngx_http_lua_ctx_t *ctx);
+
+void ngx_http_lua_cleanup_vm(void *data);
+
+ngx_connection_t * ngx_http_lua_create_fake_connection(ngx_pool_t *pool);
+
+ngx_http_request_t * ngx_http_lua_create_fake_request(ngx_connection_t *c);
+
+ngx_int_t ngx_http_lua_report(ngx_log_t *log, lua_State *L, int status,
+    const char *prefix);
+
+int ngx_http_lua_do_call(ngx_log_t *log, lua_State *L);
+
+
+#define ngx_http_lua_check_if_abortable(L, ctx)                             \
+    if ((ctx)->no_abort) {                                                  \
+        return luaL_error(L, "attempt to abort with pending subrequests");  \
+    }
+
+
+static ngx_inline void
+ngx_http_lua_init_ctx(ngx_http_request_t *r, ngx_http_lua_ctx_t *ctx)
+{
+    ngx_memzero(ctx, sizeof(ngx_http_lua_ctx_t));
+    ctx->ctx_ref = LUA_NOREF;
+    ctx->entry_co_ctx.co_ref = LUA_NOREF;
+    ctx->resume_handler = ngx_http_lua_wev_handler;
+    ctx->request = r;
+}
+
+
+static ngx_inline ngx_http_lua_ctx_t *
+ngx_http_lua_create_ctx(ngx_http_request_t *r)
+{
+    lua_State                   *L;
+    ngx_http_lua_ctx_t          *ctx;
+    ngx_pool_cleanup_t          *cln;
+    ngx_http_lua_loc_conf_t     *llcf;
+    ngx_http_lua_main_conf_t    *lmcf;
+
+    ctx = ngx_palloc(r->pool, sizeof(ngx_http_lua_ctx_t));
+    if (ctx == NULL) {
+        return NULL;
+    }
+
+    ngx_http_lua_init_ctx(r, ctx);
+    ngx_http_set_ctx(r, ctx, ngx_http_lua_module);
+
+    llcf = ngx_http_get_module_loc_conf(r, ngx_http_lua_module);
+    if (!llcf->enable_code_cache && r->connection->fd != -1) {
+        lmcf = ngx_http_get_module_main_conf(r, ngx_http_lua_module);
+
+        dd("lmcf: %p", lmcf);
+
+        L = ngx_http_lua_init_vm(lmcf->lua, lmcf->cycle, r->pool, lmcf,
+                                 r->connection->log, &cln);
+        if (L == NULL) {
+            ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
+                          "failed to initialize Lua VM");
+            return NULL;
+        }
+
+        if (lmcf->init_handler) {
+            if (lmcf->init_handler(r->connection->log, lmcf, L) != NGX_OK) {
+                /* an error happened */
+                return NULL;
+            }
+        }
+
+        ctx->vm_state = cln->data;
+
+    } else {
+        ctx->vm_state = NULL;
+    }
+
+    return ctx;
+}
+
+
+static ngx_inline lua_State *
+ngx_http_lua_get_lua_vm(ngx_http_request_t *r, ngx_http_lua_ctx_t *ctx)
+{
+    ngx_http_lua_main_conf_t    *lmcf;
+
+    if (ctx == NULL) {
+        ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
+    }
+
+    if (ctx && ctx->vm_state) {
+        return ctx->vm_state->vm;
+    }
+
+    lmcf = ngx_http_get_module_main_conf(r, ngx_http_lua_module);
+    dd("lmcf->lua: %p", lmcf->lua);
+    return lmcf->lua;
+}
+
+
+#define ngx_http_lua_req_key  "__ngx_req"
+
+
+static ngx_inline ngx_http_request_t *
+ngx_http_lua_get_req(lua_State *L)
+{
+    ngx_http_request_t    *r;
+
+    lua_getglobal(L, ngx_http_lua_req_key);
+    r = lua_touserdata(L, -1);
+    lua_pop(L, 1);
+
+    return r;
+}
+
+
+static ngx_inline void
+ngx_http_lua_set_req(lua_State *L, ngx_http_request_t *r)
+{
+    lua_pushlightuserdata(L, r);
+    lua_setglobal(L, ngx_http_lua_req_key);
+}
+
+
+static ngx_inline void
+ngx_http_lua_get_globals_table(lua_State *L)
+{
+    lua_pushvalue(L, LUA_GLOBALSINDEX);
+}
+
+
+static ngx_inline void
+ngx_http_lua_set_globals_table(lua_State *L)
+{
+    lua_replace(L, LUA_GLOBALSINDEX);
+}
+
+
+#define ngx_http_lua_hash_literal(s)                                        \
+    ngx_http_lua_hash_str((u_char *) s, sizeof(s) - 1)
+
+
+static ngx_inline ngx_uint_t
+ngx_http_lua_hash_str(u_char *src, size_t n)
+{
+    ngx_uint_t  key;
+
+    key = 0;
+
+    while (n--) {
+        key = ngx_hash(key, *src);
+        src++;
+    }
+
+    return key;
+}
+
+
+static ngx_inline ngx_int_t
+ngx_http_lua_set_content_type(ngx_http_request_t *r)
+{
+    ngx_http_lua_loc_conf_t     *llcf;
+
+    llcf = ngx_http_get_module_loc_conf(r, ngx_http_lua_module);
+    if (llcf->use_default_type) {
+        return ngx_http_set_content_type(r);
+    }
+
+    return NGX_OK;
+}
+
+
+static ngx_inline void
+ngx_http_lua_cleanup_pending_operation(ngx_http_lua_co_ctx_t *coctx)
+{
+    if (coctx->cleanup) {
+        coctx->cleanup(coctx);
+        coctx->cleanup = NULL;
+    }
+}
+
+
+static ngx_inline ngx_chain_t *
+ngx_http_lua_get_flush_chain(ngx_http_request_t *r, ngx_http_lua_ctx_t *ctx)
+{
+    ngx_chain_t  *cl;
+
+    cl = ngx_http_lua_chain_get_free_buf(r->connection->log, r->pool,
+                                         &ctx->free_bufs, 0);
+    if (cl == NULL) {
+        return NULL;
+    }
+
+    cl->buf->flush = 1;
+
+    return cl;
+}
+
+
+extern ngx_uint_t  ngx_http_lua_location_hash;
+extern ngx_uint_t  ngx_http_lua_content_length_hash;
+
+
+#endif /* _NGX_HTTP_LUA_UTIL_H_INCLUDED_ */
+
+/* vi:set ft=c ts=4 sw=4 et fdm=marker: */

data/packaging/debian/debian_specs/nginx/modules/nginx-lua/src/ngx_http_lua_variable.c

@@ -0,0 +1,499 @@
+
+/*
+ * Copyright (C) Xiaozhe Wang (chaoslawful)
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef DDEBUG
+#define DDEBUG 0
+#endif
+#include "ddebug.h"
+
+
+#include "ngx_http_lua_variable.h"
+#include "ngx_http_lua_util.h"
+
+
+static int ngx_http_lua_var_get(lua_State *L);
+static int ngx_http_lua_var_set(lua_State *L);
+
+
+void
+ngx_http_lua_inject_variable_api(lua_State *L)
+{
+    /* {{{ register reference maps */
+    lua_newtable(L);    /* ngx.var */
+
+    lua_createtable(L, 0, 2 /* nrec */); /* metatable for .var */
+    lua_pushcfunction(L, ngx_http_lua_var_get);
+    lua_setfield(L, -2, "__index");
+    lua_pushcfunction(L, ngx_http_lua_var_set);
+    lua_setfield(L, -2, "__newindex");
+    lua_setmetatable(L, -2);
+
+    lua_setfield(L, -2, "var");
+}
+
+
+/**
+ * Get nginx internal variables content
+ *
+ * @retval Always return a string or nil on Lua stack. Return nil when failed
+ * to get content, and actual content string when found the specified variable.
+ * @seealso ngx_http_lua_var_set
+ * */
+static int
+ngx_http_lua_var_get(lua_State *L)
+{
+    ngx_http_request_t          *r;
+    u_char                      *p, *lowcase;
+    size_t                       len;
+    ngx_uint_t                   hash;
+    ngx_str_t                    name;
+    ngx_http_variable_value_t   *vv;
+
+#if (NGX_PCRE)
+    u_char                      *val;
+    ngx_uint_t                   n;
+    LUA_NUMBER                   index;
+    int                         *cap;
+#endif
+
+    r = ngx_http_lua_get_req(L);
+    if (r == NULL) {
+        return luaL_error(L, "no request object found");
+    }
+
+    ngx_http_lua_check_fake_request(L, r);
+
+#if (NGX_PCRE)
+    if (lua_type(L, -1) == LUA_TNUMBER) {
+        /* it is a regex capturing variable */
+
+        index = lua_tonumber(L, -1);
+
+        if (index <= 0) {
+            lua_pushnil(L);
+            return 1;
+        }
+
+        n = (ngx_uint_t) index * 2;
+
+        dd("n = %d, ncaptures = %d", (int) n, (int) r->ncaptures);
+
+        if (r->captures == NULL
+            || r->captures_data == NULL
+            || n >= r->ncaptures)
+        {
+            lua_pushnil(L);
+            return 1;
+        }
+
+        /* n >= 0 && n < r->ncaptures */
+
+        cap = r->captures;
+
+        p = r->captures_data;
+
+        val = &p[cap[n]];
+
+        lua_pushlstring(L, (const char *) val, (size_t) (cap[n + 1] - cap[n]));
+
+        return 1;
+    }
+#endif
+
+    if (lua_type(L, -1) != LUA_TSTRING) {
+        return luaL_error(L, "bad variable name");
+    }
+
+    p = (u_char *) lua_tolstring(L, -1, &len);
+
+    lowcase = lua_newuserdata(L, len);
+
+    hash = ngx_hash_strlow(lowcase, p, len);
+
+    name.len = len;
+    name.data = lowcase;
+
+    vv = ngx_http_get_variable(r, &name, hash);
+
+    if (vv == NULL || vv->not_found) {
+        lua_pushnil(L);
+        return 1;
+    }
+
+    lua_pushlstring(L, (const char *) vv->data, (size_t) vv->len);
+    return 1;
+}
+
+
+/**
+ * Set nginx internal variable content
+ *
+ * @retval Always return a boolean on Lua stack. Return true when variable
+ * content was modified successfully, false otherwise.
+ * @seealso ngx_http_lua_var_get
+ * */
+static int
+ngx_http_lua_var_set(lua_State *L)
+{
+    ngx_http_variable_t         *v;
+    ngx_http_variable_value_t   *vv;
+    ngx_http_core_main_conf_t   *cmcf;
+    u_char                      *p, *lowcase, *val;
+    size_t                       len;
+    ngx_str_t                    name;
+    ngx_uint_t                   hash;
+    ngx_http_request_t          *r;
+    int                          value_type;
+    const char                  *msg;
+
+    r = ngx_http_lua_get_req(L);
+    if (r == NULL) {
+        return luaL_error(L, "no request object found");
+    }
+
+    ngx_http_lua_check_fake_request(L, r);
+
+    /* we skip the first argument that is the table */
+
+    /* we read the variable name */
+
+    if (lua_type(L, 2) != LUA_TSTRING) {
+        return luaL_error(L, "bad variable name");
+    }
+
+    p = (u_char *) lua_tolstring(L, 2, &len);
+
+    lowcase = lua_newuserdata(L, len + 1);
+
+    hash = ngx_hash_strlow(lowcase, p, len);
+    lowcase[len] = '\0';
+
+    name.len = len;
+    name.data = lowcase;
+
+    /* we read the variable new value */
+
+    value_type = lua_type(L, 3);
+    switch (value_type) {
+    case LUA_TNUMBER:
+    case LUA_TSTRING:
+        p = (u_char *) luaL_checklstring(L, 3, &len);
+
+        val = ngx_palloc(r->pool, len);
+        if (val == NULL) {
+            return luaL_error(L, "memory allocation erorr");
+        }
+
+        ngx_memcpy(val, p, len);
+
+        break;
+
+    case LUA_TNIL:
+        /* undef the variable */
+
+        val = NULL;
+        len = 0;
+
+        break;
+
+    default:
+        msg = lua_pushfstring(L, "string, number, or nil expected, "
+                              "but got %s", lua_typename(L, value_type));
+        return luaL_argerror(L, 1, msg);
+    }
+
+    /* we fetch the variable itself */
+
+    cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
+
+    v = ngx_hash_find(&cmcf->variables_hash, hash, name.data, name.len);
+
+    if (v) {
+        if (!(v->flags & NGX_HTTP_VAR_CHANGEABLE)) {
+            return luaL_error(L, "variable \"%s\" not changeable", lowcase);
+        }
+
+        if (v->set_handler) {
+
+            dd("set variables with set_handler");
+
+            vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
+            if (vv == NULL) {
+                return luaL_error(L, "no memory");
+            }
+
+            if (value_type == LUA_TNIL) {
+                vv->valid = 0;
+                vv->not_found = 1;
+                vv->no_cacheable = 0;
+                vv->data = NULL;
+                vv->len = 0;
+
+            } else {
+                vv->valid = 1;
+                vv->not_found = 0;
+                vv->no_cacheable = 0;
+
+                vv->data = val;
+                vv->len = len;
+            }
+
+            v->set_handler(r, vv, v->data);
+
+            return 0;
+        }
+
+        if (v->flags & NGX_HTTP_VAR_INDEXED) {
+            vv = &r->variables[v->index];
+
+            dd("set indexed variable");
+
+            if (value_type == LUA_TNIL) {
+                vv->valid = 0;
+                vv->not_found = 1;
+                vv->no_cacheable = 0;
+
+                vv->data = NULL;
+                vv->len = 0;
+
+            } else {
+                vv->valid = 1;
+                vv->not_found = 0;
+                vv->no_cacheable = 0;
+
+                vv->data = val;
+                vv->len = len;
+            }
+
+            return 0;
+        }
+
+        return luaL_error(L, "variable \"%s\" cannot be assigned a value",
+                          lowcase);
+    }
+
+    /* variable not found */
+
+    return luaL_error(L, "variable \"%s\" not found for writing; "
+                      "maybe it is a built-in variable that is not changeable "
+                      "or you forgot to use \"set $%s '';\" "
+                      "in the config file to define it first",
+                      lowcase, lowcase);
+}
+
+
+#ifndef NGX_LUA_NO_FFI_API
+int
+ngx_http_lua_ffi_var_get(ngx_http_request_t *r, u_char *name_data,
+    size_t name_len, u_char *lowcase_buf, int capture_id, u_char **value,
+    size_t *value_len, char **err)
+{
+    ngx_uint_t                   hash;
+    ngx_str_t                    name;
+    ngx_http_variable_value_t   *vv;
+
+#if (NGX_PCRE)
+    u_char                      *p;
+    ngx_uint_t                   n;
+    int                         *cap;
+#endif
+
+    if (r == NULL) {
+        *err = "no request object found";
+        return NGX_ERROR;
+    }
+
+    if ((r)->connection->fd == -1) {
+        *err = "API disabled in the current context";
+        return NGX_ERROR;
+    }
+
+#if (NGX_PCRE)
+    if (name_data == 0) {
+        if (capture_id <= 0) {
+            return NGX_DECLINED;
+        }
+
+        /* it is a regex capturing variable */
+
+        n = (ngx_uint_t) capture_id * 2;
+
+        dd("n = %d, ncaptures = %d", (int) n, (int) r->ncaptures);
+
+        if (r->captures == NULL
+            || r->captures_data == NULL
+            || n >= r->ncaptures)
+        {
+            return NGX_DECLINED;
+        }
+
+        /* n >= 0 && n < r->ncaptures */
+
+        cap = r->captures;
+        p = r->captures_data;
+
+        *value = &p[cap[n]];
+        *value_len = (size_t) (cap[n + 1] - cap[n]);
+
+        return NGX_OK;
+    }
+#endif
+
+    hash = ngx_hash_strlow(lowcase_buf, name_data, name_len);
+
+    name.data = lowcase_buf;
+    name.len = name_len;
+
+    dd("variable name: %.*s", (int) name_len, lowcase_buf);
+
+    vv = ngx_http_get_variable(r, &name, hash);
+    if (vv == NULL || vv->not_found) {
+        return NGX_DECLINED;
+    }
+
+    *value = vv->data;
+    *value_len = vv->len;
+    return NGX_OK;
+}
+
+
+int
+ngx_http_lua_ffi_var_set(ngx_http_request_t *r, u_char *name_data,
+    size_t name_len, u_char *lowcase_buf, u_char *value, size_t value_len,
+    u_char *errbuf, size_t errlen)
+{
+    u_char                      *p;
+    ngx_uint_t                   hash;
+    ngx_http_variable_t         *v;
+    ngx_http_variable_value_t   *vv;
+    ngx_http_core_main_conf_t   *cmcf;
+
+    if (r == NULL) {
+        ngx_snprintf(errbuf, errlen, "no request object found");
+        return NGX_ERROR;
+    }
+
+    if ((r)->connection->fd == -1) {
+        ngx_snprintf(errbuf, errlen, "API disabled in the current context");
+        return NGX_ERROR;
+    }
+
+    hash = ngx_hash_strlow(lowcase_buf, name_data, name_len);
+
+    dd("variable name: %.*s", (int) name_len, lowcase_buf);
+
+    /* we fetch the variable itself */
+
+    cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
+
+    v = ngx_hash_find(&cmcf->variables_hash, hash, lowcase_buf, name_len);
+
+    if (v) {
+        if (!(v->flags & NGX_HTTP_VAR_CHANGEABLE)) {
+            dd("variable not changeable");
+            ngx_snprintf(errbuf, errlen, "variable \"%*s\" not changeable",
+                         name_len, lowcase_buf);
+            return NGX_ERROR;
+        }
+
+        if (v->set_handler) {
+
+            dd("set variables with set_handler");
+
+            if (value != NULL && value_len) {
+                vv = ngx_pnalloc(r->pool, sizeof(ngx_http_variable_value_t)
+                                 + value_len);
+                if (vv == NULL) {
+                    goto nomem;
+                }
+
+                p = (u_char *) vv + sizeof(ngx_http_variable_value_t);
+                ngx_memcpy(p, value, value_len);
+                value = p;
+
+            } else {
+                vv = ngx_palloc(r->pool, sizeof(ngx_http_variable_value_t));
+                if (vv == NULL) {
+                    goto nomem;
+                }
+            }
+
+            if (value == NULL) {
+                vv->valid = 0;
+                vv->not_found = 1;
+                vv->no_cacheable = 0;
+                vv->data = NULL;
+                vv->len = 0;
+
+            } else {
+                vv->valid = 1;
+                vv->not_found = 0;
+                vv->no_cacheable = 0;
+
+                vv->data = value;
+                vv->len = value_len;
+            }
+
+            v->set_handler(r, vv, v->data);
+            return NGX_OK;
+        }
+
+        if (v->flags & NGX_HTTP_VAR_INDEXED) {
+            vv = &r->variables[v->index];
+
+            dd("set indexed variable");
+
+            if (value == NULL) {
+                vv->valid = 0;
+                vv->not_found = 1;
+                vv->no_cacheable = 0;
+
+                vv->data = NULL;
+                vv->len = 0;
+
+            } else {
+                p = ngx_palloc(r->pool, value_len);
+                if (p == NULL) {
+                    goto nomem;
+                }
+                ngx_memcpy(p, value, value_len);
+                value = p;
+
+                vv->valid = 1;
+                vv->not_found = 0;
+                vv->no_cacheable = 0;
+
+                vv->data = value;
+                vv->len = value_len;
+            }
+
+            return NGX_OK;
+        }
+
+        ngx_snprintf(errbuf, errlen, "variable \"%*s\" cannot be assigned "
+                     "a value", name_len, lowcase_buf);
+        return NGX_ERROR;
+    }
+
+    /* variable not found */
+
+    ngx_snprintf(errbuf, errlen, "variable \"%*s\" not found for writing; "
+                 "maybe it is a built-in variable that is not changeable "
+                 "or you forgot to use \"set $%*s '';\" "
+                 "in the config file to define it first",
+                 name_len, lowcase_buf, name_len, lowcase_buf);
+    return NGX_ERROR;
+
+nomem:
+
+    ngx_snprintf(errbuf, errlen, "no memory");
+    return NGX_ERROR;
+}
+#endif /* NGX_LUA_NO_FFI_API */
+
+
+/* vi:set ft=c ts=4 sw=4 et fdm=marker: */