passenger 4.0.59 → 4.0.60

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

@@ -0,0 +1,31 @@
+
+/*
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef _NGX_HTTP_LUA_BODYFILTERBY_H_INCLUDED_
+#define _NGX_HTTP_LUA_BODYFILTERBY_H_INCLUDED_
+
+
+#include "ngx_http_lua_common.h"
+
+
+extern ngx_http_output_body_filter_pt ngx_http_lua_next_filter_body_filter;
+
+
+ngx_int_t ngx_http_lua_body_filter_init(void);
+ngx_int_t ngx_http_lua_body_filter_by_chunk(lua_State *L,
+    ngx_http_request_t *r, ngx_chain_t *in);
+ngx_int_t ngx_http_lua_body_filter_inline(ngx_http_request_t *r,
+    ngx_chain_t *in);
+ngx_int_t ngx_http_lua_body_filter_file(ngx_http_request_t *r,
+    ngx_chain_t *in);
+int ngx_http_lua_body_filter_param_get(lua_State *L);
+int ngx_http_lua_body_filter_param_set(lua_State *L, ngx_http_request_t *r,
+    ngx_http_lua_ctx_t *ctx);
+
+
+#endif /* _NGX_HTTP_LUA_BODYFILTERBY_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_cache.c

@@ -0,0 +1,296 @@
+
+/*
+ * Copyright (C) Xiaozhe Wang (chaoslawful)
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef DDEBUG
+#define DDEBUG 0
+#endif
+#include "ddebug.h"
+
+
+#include <nginx.h>
+#include <ngx_md5.h>
+#include "ngx_http_lua_common.h"
+#include "ngx_http_lua_cache.h"
+#include "ngx_http_lua_clfactory.h"
+#include "ngx_http_lua_util.h"
+
+
+/**
+ * Find code chunk associated with the given key in code cache,
+ * and push it to the top of Lua stack if found.
+ *
+ * Stack layout before call:
+ *         |     ...    | <- top
+ *
+ * Stack layout after call:
+ *         | code chunk | <- top
+ *         |     ...    |
+ *
+ * */
+static ngx_int_t
+ngx_http_lua_cache_load_code(ngx_http_request_t *r, lua_State *L,
+    const char *key)
+{
+    int          rc;
+    u_char      *err;
+
+    /*  get code cache table */
+    lua_pushlightuserdata(L, &ngx_http_lua_code_cache_key);
+    lua_rawget(L, LUA_REGISTRYINDEX);    /*  sp++ */
+
+    dd("Code cache table to load: %p", lua_topointer(L, -1));
+
+    if (!lua_istable(L, -1)) {
+        dd("Error: code cache table to load did not exist!!");
+        return NGX_ERROR;
+    }
+
+    lua_getfield(L, -1, key);    /*  sp++ */
+
+    if (lua_isfunction(L, -1)) {
+        /*  call closure factory to gen new closure */
+        rc = lua_pcall(L, 0, 1, 0);
+        if (rc == 0) {
+            /*  remove cache table from stack, leave code chunk at
+             *  top of stack */
+            lua_remove(L, -2);   /*  sp-- */
+            return NGX_OK;
+        }
+
+        if (lua_isstring(L, -1)) {
+            err = (u_char *) lua_tostring(L, -1);
+
+        } else {
+            err = (u_char *) "unknown error";
+        }
+
+        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
+                      "lua: failed to run factory at key \"%s\": %s",
+                      key, err);
+        lua_pop(L, 2);
+        return NGX_ERROR;
+    }
+
+    dd("Value associated with given key in code cache table is not code "
+       "chunk: stack top=%d, top value type=%s\n",
+       lua_gettop(L), lua_typename(L, -1));
+
+    /*  remove cache table and value from stack */
+    lua_pop(L, 2);                                /*  sp-=2 */
+
+    return NGX_DECLINED;
+}
+
+
+/**
+ * Store the closure factory at the top of Lua stack to code cache, and
+ * associate it with the given key. Then generate new closure.
+ *
+ * Stack layout before call:
+ *         | code factory | <- top
+ *         |     ...      |
+ *
+ * Stack layout after call:
+ *         | code chunk | <- top
+ *         |     ...    |
+ *
+ * */
+static ngx_int_t
+ngx_http_lua_cache_store_code(lua_State *L, const char *key)
+{
+    int rc;
+
+    /*  get code cache table */
+    lua_pushlightuserdata(L, &ngx_http_lua_code_cache_key);
+    lua_rawget(L, LUA_REGISTRYINDEX);
+
+    dd("Code cache table to store: %p", lua_topointer(L, -1));
+
+    if (!lua_istable(L, -1)) {
+        dd("Error: code cache table to load did not exist!!");
+        return NGX_ERROR;
+    }
+
+    lua_pushvalue(L, -2); /* closure cache closure */
+    lua_setfield(L, -2, key); /* closure cache */
+
+    /*  remove cache table, leave closure factory at top of stack */
+    lua_pop(L, 1); /* closure */
+
+    /*  call closure factory to generate new closure */
+    rc = lua_pcall(L, 0, 1, 0);
+    if (rc != 0) {
+        dd("Error: failed to call closure factory!!");
+        return NGX_ERROR;
+    }
+
+    return NGX_OK;
+}
+
+
+ngx_int_t
+ngx_http_lua_cache_loadbuffer(ngx_http_request_t *r, lua_State *L,
+    const u_char *src, size_t src_len, const u_char *cache_key,
+    const char *name)
+{
+    int          n;
+    ngx_int_t    rc;
+    const char  *err = NULL;
+
+    n = lua_gettop(L);
+
+    dd("XXX cache key: [%s]", cache_key);
+
+    rc = ngx_http_lua_cache_load_code(r, L, (char *) cache_key);
+    if (rc == NGX_OK) {
+        /*  code chunk loaded from cache, sp++ */
+        dd("Code cache hit! cache key='%s', stack top=%d, script='%.*s'",
+           cache_key, lua_gettop(L), (int) src_len, src);
+        return NGX_OK;
+    }
+
+    if (rc == NGX_ERROR) {
+        return NGX_ERROR;
+    }
+
+    /* rc == NGX_DECLINED */
+
+    dd("Code cache missed! cache key='%s', stack top=%d, script='%.*s'",
+       cache_key, lua_gettop(L), (int) src_len, src);
+
+    /* load closure factory of inline script to the top of lua stack, sp++ */
+    rc = ngx_http_lua_clfactory_loadbuffer(L, (char *) src, src_len, name);
+
+    if (rc != 0) {
+        /*  Oops! error occured when loading Lua script */
+        if (rc == LUA_ERRMEM) {
+            err = "memory allocation error";
+
+        } else {
+            if (lua_isstring(L, -1)) {
+                err = lua_tostring(L, -1);
+
+            } else {
+                err = "unknown error";
+            }
+        }
+
+        goto error;
+    }
+
+    /*  store closure factory and gen new closure at the top of lua stack to
+     *  code cache */
+    rc = ngx_http_lua_cache_store_code(L, (char *) cache_key);
+    if (rc != NGX_OK) {
+        err = "fail to generate new closure from the closure factory";
+        goto error;
+    }
+
+    return NGX_OK;
+
+error:
+
+    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
+                  "failed to load inlined Lua code: %s", err);
+    lua_settop(L, n);
+    return NGX_ERROR;
+}
+
+
+ngx_int_t
+ngx_http_lua_cache_loadfile(ngx_http_request_t *r, lua_State *L,
+    const u_char *script, const u_char *cache_key)
+{
+    int              n;
+    ngx_int_t        rc, errcode = NGX_ERROR;
+    u_char          *p;
+    u_char           buf[NGX_HTTP_LUA_FILE_KEY_LEN + 1];
+    const char      *err = NULL;
+
+    n = lua_gettop(L);
+
+    /*  calculate digest of script file path */
+    if (cache_key == NULL) {
+        dd("CACHE file key not pre-calculated...calculating");
+        p = ngx_copy(buf, NGX_HTTP_LUA_FILE_TAG, NGX_HTTP_LUA_FILE_TAG_LEN);
+
+        p = ngx_http_lua_digest_hex(p, script, ngx_strlen(script));
+
+        *p = '\0';
+        cache_key = buf;
+
+    } else {
+        dd("CACHE file key already pre-calculated");
+    }
+
+    dd("XXX cache key for file: [%s]", cache_key);
+
+    rc = ngx_http_lua_cache_load_code(r, L, (char *) cache_key);
+    if (rc == NGX_OK) {
+        /*  code chunk loaded from cache, sp++ */
+        dd("Code cache hit! cache key='%s', stack top=%d, file path='%s'",
+           cache_key, lua_gettop(L), script);
+        return NGX_OK;
+    }
+
+    if (rc == NGX_ERROR) {
+        return NGX_ERROR;
+    }
+
+    /* rc == NGX_DECLINED */
+
+    dd("Code cache missed! cache key='%s', stack top=%d, file path='%s'",
+       cache_key, lua_gettop(L), script);
+
+    /*  load closure factory of script file to the top of lua stack, sp++ */
+    rc = ngx_http_lua_clfactory_loadfile(L, (char *) script);
+
+    dd("loadfile returns %d (%d)", (int) rc, LUA_ERRFILE);
+
+    if (rc != 0) {
+        /*  Oops! error occured when loading Lua script */
+        switch (rc) {
+        case LUA_ERRMEM:
+            err = "memory allocation error";
+            break;
+
+        case LUA_ERRFILE:
+            errcode = NGX_HTTP_NOT_FOUND;
+            /* fall through */
+
+        default:
+            if (lua_isstring(L, -1)) {
+                err = lua_tostring(L, -1);
+
+            } else {
+                err = "unknown error";
+            }
+        }
+
+        goto error;
+    }
+
+    /*  store closure factory and gen new closure at the top of lua stack
+     *  to code cache */
+    rc = ngx_http_lua_cache_store_code(L, (char *) cache_key);
+    if (rc != NGX_OK) {
+        err = "fail to generate new closure from the closure factory";
+        goto error;
+    }
+
+    return NGX_OK;
+
+error:
+
+    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
+                  "failed to load external Lua file \"%s\": %s", script, err);
+
+    lua_settop(L, n);
+    return errcode;
+}
+
+/* vi:set ft=c ts=4 sw=4 et fdm=marker: */

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

@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) Xiaozhe Wang (chaoslawful)
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef _NGX_HTTP_LUA_CACHE_H_INCLUDED_
+#define _NGX_HTTP_LUA_CACHE_H_INCLUDED_
+
+
+#include "ngx_http_lua_common.h"
+
+
+ngx_int_t ngx_http_lua_cache_loadbuffer(ngx_http_request_t *r, lua_State *L,
+    const u_char *src, size_t src_len, const u_char *cache_key,
+    const char *name);
+ngx_int_t ngx_http_lua_cache_loadfile(ngx_http_request_t *r, lua_State *L,
+    const u_char *script, const u_char *cache_key);
+
+
+#endif /* _NGX_HTTP_LUA_CACHE_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_capturefilter.c

@@ -0,0 +1,175 @@
+
+/*
+ * Copyright (C) Xiaozhe Wang (chaoslawful)
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef DDEBUG
+#define DDEBUG 0
+#endif
+#include "ddebug.h"
+
+
+#include <nginx.h>
+#include "ngx_http_lua_capturefilter.h"
+#include "ngx_http_lua_util.h"
+#include "ngx_http_lua_exception.h"
+#include "ngx_http_lua_subrequest.h"
+
+
+ngx_http_output_header_filter_pt ngx_http_lua_next_header_filter;
+ngx_http_output_body_filter_pt ngx_http_lua_next_body_filter;
+
+
+static ngx_int_t ngx_http_lua_capture_header_filter(ngx_http_request_t *r);
+static ngx_int_t ngx_http_lua_capture_body_filter(ngx_http_request_t *r,
+    ngx_chain_t *in);
+
+
+ngx_int_t
+ngx_http_lua_capture_filter_init(ngx_conf_t *cf)
+{
+    /* setting up output filters to intercept subrequest responses */
+    ngx_http_lua_next_header_filter = ngx_http_top_header_filter;
+    ngx_http_top_header_filter = ngx_http_lua_capture_header_filter;
+
+    ngx_http_lua_next_body_filter = ngx_http_top_body_filter;
+    ngx_http_top_body_filter = ngx_http_lua_capture_body_filter;
+
+    return NGX_OK;
+}
+
+
+static ngx_int_t
+ngx_http_lua_capture_header_filter(ngx_http_request_t *r)
+{
+    ngx_http_post_subrequest_t      *psr;
+    ngx_http_lua_ctx_t              *old_ctx;
+    ngx_http_lua_ctx_t              *ctx;
+
+    ngx_http_lua_post_subrequest_data_t      *psr_data;
+
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "lua capture header filter, uri \"%V\"", &r->uri);
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
+
+    dd("old ctx: %p", ctx);
+
+    if (ctx == NULL || ! ctx->capture) {
+
+        psr = r->post_subrequest;
+
+        if (psr != NULL
+            && psr->handler == ngx_http_lua_post_subrequest
+            && psr->data != NULL)
+        {
+            /* the lua ctx has been cleared by ngx_http_internal_redirect,
+             * resume it from the post_subrequest data
+             */
+            psr_data = psr->data;
+
+            old_ctx = psr_data->ctx;
+
+            if (ctx == NULL) {
+                ctx = old_ctx;
+                ngx_http_set_ctx(r, ctx, ngx_http_lua_module);
+
+            } else {
+                ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                               "lua restoring ctx with capture %d, index %d",
+                               old_ctx->capture, old_ctx->index);
+
+                ctx->capture = old_ctx->capture;
+                ctx->index = old_ctx->index;
+                ctx->body = NULL;
+                ctx->last_body = &ctx->body;
+                psr_data->ctx = ctx;
+            }
+        }
+    }
+
+    if (ctx && ctx->capture) {
+        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                       "lua capturing response body");
+
+        /* force subrequest response body buffer in memory */
+        r->filter_need_in_memory = 1;
+        r->header_sent = 1;
+
+        if (r->method == NGX_HTTP_HEAD) {
+            r->header_only = 1;
+        }
+
+        return NGX_OK;
+    }
+
+    return ngx_http_lua_next_header_filter(r);
+}
+
+
+static ngx_int_t
+ngx_http_lua_capture_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
+{
+    int                              rc;
+    ngx_int_t                        eof;
+    ngx_http_lua_ctx_t              *ctx;
+    ngx_http_lua_ctx_t              *pr_ctx;
+
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "lua capture body filter, uri \"%V\"", &r->uri);
+
+    if (in == NULL) {
+        return ngx_http_lua_next_body_filter(r, NULL);
+    }
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
+
+    if (!ctx || !ctx->capture) {
+        dd("no ctx or no capture %.*s", (int) r->uri.len, r->uri.data);
+
+        return ngx_http_lua_next_body_filter(r, in);
+    }
+
+    if (ctx->run_post_subrequest) {
+        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                       "lua body filter skipped because post subrequest "
+                       "already run");
+        return NGX_OK;
+    }
+
+    if (r->parent == NULL) {
+        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                       "lua body filter skipped because no parent request "
+                       "found");
+
+        return NGX_ERROR;
+    }
+
+    pr_ctx = ngx_http_get_module_ctx(r->parent, ngx_http_lua_module);
+    if (pr_ctx == NULL) {
+        return NGX_ERROR;
+    }
+
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "lua capture body filter capturing response body, uri "
+                   "\"%V\"", &r->uri);
+
+    rc = ngx_http_lua_add_copy_chain(r, pr_ctx, &ctx->last_body, in, &eof);
+    if (rc != NGX_OK) {
+        return NGX_ERROR;
+    }
+
+    dd("add copy chain eof: %d, sr: %d", (int) eof, r != r->main);
+
+    if (eof) {
+        ctx->seen_last_for_subreq = 1;
+    }
+
+    ngx_http_lua_discard_bufs(r->pool, in);
+
+    return NGX_OK;
+}
+
+/* vi:set ft=c ts=4 sw=4 et fdm=marker: */