passenger 4.0.59 → 4.0.60

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

@@ -0,0 +1,67 @@
+
+/*
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef DDEBUG
+#define DDEBUG 0
+#endif
+#include "ddebug.h"
+
+
+#include "ngx_http_lua_config.h"
+#include "api/ngx_http_lua_api.h"
+
+
+static int ngx_http_lua_config_prefix(lua_State *L);
+static int ngx_http_lua_config_configure(lua_State *L);
+
+
+void
+ngx_http_lua_inject_config_api(lua_State *L)
+{
+    /* ngx.config */
+
+    lua_createtable(L, 0, 5 /* nrec */);    /* .config */
+
+#if (NGX_DEBUG)
+    lua_pushboolean(L, 1);
+#else
+    lua_pushboolean(L, 0);
+#endif
+    lua_setfield(L, -2, "debug");
+
+    lua_pushcfunction(L, ngx_http_lua_config_prefix);
+    lua_setfield(L, -2, "prefix");
+
+    lua_pushinteger(L, nginx_version);
+    lua_setfield(L, -2, "nginx_version");
+
+    lua_pushinteger(L, ngx_http_lua_version);
+    lua_setfield(L, -2, "ngx_lua_version");
+
+    lua_pushcfunction(L, ngx_http_lua_config_configure);
+    lua_setfield(L, -2, "nginx_configure");
+
+    lua_setfield(L, -2, "config");
+}
+
+
+static int
+ngx_http_lua_config_prefix(lua_State *L)
+{
+    lua_pushlstring(L, (char *) ngx_cycle->prefix.data,
+                    ngx_cycle->prefix.len);
+    return 1;
+}
+
+
+static int
+ngx_http_lua_config_configure(lua_State *L)
+{
+    lua_pushliteral(L, NGX_CONFIGURE);
+    return 1;
+}
+
+/* vi:set ft=c ts=4 sw=4 et fdm=marker: */

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

@@ -0,0 +1,19 @@
+
+/*
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef _NGX_HTTP_LUA_CONFIG_H_INCLUDED_
+#define _NGX_HTTP_LUA_CONFIG_H_INCLUDED_
+
+
+#include "ngx_http_lua_common.h"
+
+
+void ngx_http_lua_inject_config_api(lua_State *L);
+
+
+#endif /* _NGX_HTTP_LUA_CONFIG_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_consts.c

@@ -0,0 +1,148 @@
+
+/*
+ * Copyright (C) Xiaozhe Wang (chaoslawful)
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef DDEBUG
+#define DDEBUG 0
+#endif
+#include "ddebug.h"
+
+
+#include "ngx_http_lua_consts.h"
+
+
+void
+ngx_http_lua_inject_core_consts(lua_State *L)
+{
+    /* {{{ core constants */
+    lua_pushinteger(L, NGX_OK);
+    lua_setfield(L, -2, "OK");
+
+    lua_pushinteger(L, NGX_AGAIN);
+    lua_setfield(L, -2, "AGAIN");
+
+    lua_pushinteger(L, NGX_DONE);
+    lua_setfield(L, -2, "DONE");
+
+    lua_pushinteger(L, NGX_DECLINED);
+    lua_setfield(L, -2, "DECLINED");
+
+    lua_pushinteger(L, NGX_ERROR);
+    lua_setfield(L, -2, "ERROR");
+
+    lua_pushlightuserdata(L, NULL);
+    lua_setfield(L, -2, "null");
+    /* }}} */
+}
+
+
+void
+ngx_http_lua_inject_http_consts(lua_State *L)
+{
+    /* {{{ HTTP status constants */
+    lua_pushinteger(L, NGX_HTTP_GET);
+    lua_setfield(L, -2, "HTTP_GET");
+
+    lua_pushinteger(L, NGX_HTTP_POST);
+    lua_setfield(L, -2, "HTTP_POST");
+
+    lua_pushinteger(L, NGX_HTTP_PUT);
+    lua_setfield(L, -2, "HTTP_PUT");
+
+    lua_pushinteger(L, NGX_HTTP_HEAD);
+    lua_setfield(L, -2, "HTTP_HEAD");
+
+    lua_pushinteger(L, NGX_HTTP_DELETE);
+    lua_setfield(L, -2, "HTTP_DELETE");
+
+    lua_pushinteger(L, NGX_HTTP_OPTIONS);
+    lua_setfield(L, -2, "HTTP_OPTIONS");
+
+    lua_pushinteger(L, NGX_HTTP_MKCOL);
+    lua_setfield(L, -2, "HTTP_MKCOL");
+
+    lua_pushinteger(L, NGX_HTTP_COPY);
+    lua_setfield(L, -2, "HTTP_COPY");
+
+    lua_pushinteger(L, NGX_HTTP_MOVE);
+    lua_setfield(L, -2, "HTTP_MOVE");
+
+    lua_pushinteger(L, NGX_HTTP_PROPFIND);
+    lua_setfield(L, -2, "HTTP_PROPFIND");
+
+    lua_pushinteger(L, NGX_HTTP_PROPPATCH);
+    lua_setfield(L, -2, "HTTP_PROPPATCH");
+
+    lua_pushinteger(L, NGX_HTTP_LOCK);
+    lua_setfield(L, -2, "HTTP_LOCK");
+
+    lua_pushinteger(L, NGX_HTTP_UNLOCK);
+    lua_setfield(L, -2, "HTTP_UNLOCK");
+
+    lua_pushinteger(L, NGX_HTTP_PATCH);
+    lua_setfield(L, -2, "HTTP_PATCH");
+
+    lua_pushinteger(L, NGX_HTTP_TRACE);
+    lua_setfield(L, -2, "HTTP_TRACE");
+    /* }}} */
+
+    lua_pushinteger(L, NGX_HTTP_OK);
+    lua_setfield(L, -2, "HTTP_OK");
+
+    lua_pushinteger(L, NGX_HTTP_CREATED);
+    lua_setfield(L, -2, "HTTP_CREATED");
+
+    lua_pushinteger(L, NGX_HTTP_SPECIAL_RESPONSE);
+    lua_setfield(L, -2, "HTTP_SPECIAL_RESPONSE");
+
+    lua_pushinteger(L, NGX_HTTP_MOVED_PERMANENTLY);
+    lua_setfield(L, -2, "HTTP_MOVED_PERMANENTLY");
+
+    lua_pushinteger(L, NGX_HTTP_MOVED_TEMPORARILY);
+    lua_setfield(L, -2, "HTTP_MOVED_TEMPORARILY");
+
+#if defined(nginx_version) && nginx_version >= 8042
+    lua_pushinteger(L, NGX_HTTP_SEE_OTHER);
+    lua_setfield(L, -2, "HTTP_SEE_OTHER");
+#endif
+
+    lua_pushinteger(L, NGX_HTTP_NOT_MODIFIED);
+    lua_setfield(L, -2, "HTTP_NOT_MODIFIED");
+
+    lua_pushinteger(L, NGX_HTTP_BAD_REQUEST);
+    lua_setfield(L, -2, "HTTP_BAD_REQUEST");
+
+    lua_pushinteger(L, NGX_HTTP_UNAUTHORIZED);
+    lua_setfield(L, -2, "HTTP_UNAUTHORIZED");
+
+
+    lua_pushinteger(L, NGX_HTTP_FORBIDDEN);
+    lua_setfield(L, -2, "HTTP_FORBIDDEN");
+
+    lua_pushinteger(L, NGX_HTTP_NOT_FOUND);
+    lua_setfield(L, -2, "HTTP_NOT_FOUND");
+
+    lua_pushinteger(L, NGX_HTTP_NOT_ALLOWED);
+    lua_setfield(L, -2, "HTTP_NOT_ALLOWED");
+
+    lua_pushinteger(L, 410);
+    lua_setfield(L, -2, "HTTP_GONE");
+
+    lua_pushinteger(L, NGX_HTTP_INTERNAL_SERVER_ERROR);
+    lua_setfield(L, -2, "HTTP_INTERNAL_SERVER_ERROR");
+
+    lua_pushinteger(L, NGX_HTTP_NOT_IMPLEMENTED);
+    lua_setfield(L, -2, "HTTP_METHOD_NOT_IMPLEMENTED");
+
+    lua_pushinteger(L, NGX_HTTP_SERVICE_UNAVAILABLE);
+    lua_setfield(L, -2, "HTTP_SERVICE_UNAVAILABLE");
+
+    lua_pushinteger(L, NGX_HTTP_GATEWAY_TIME_OUT);
+    lua_setfield(L, -2, "HTTP_GATEWAY_TIMEOUT");
+    /* }}} */
+}
+
+/* vi:set ft=c ts=4 sw=4 et fdm=marker: */

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

@@ -0,0 +1,20 @@
+
+/*
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef _NGX_HTTP_LUA_CONSTS_H_INCLUDED_
+#define _NGX_HTTP_LUA_CONSTS_H_INCLUDED_
+
+
+#include "ngx_http_lua_common.h"
+
+
+void ngx_http_lua_inject_http_consts(lua_State *L);
+void ngx_http_lua_inject_core_consts(lua_State *L);
+
+
+#endif /* _NGX_HTTP_LUA_CONSTS_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_contentby.c

@@ -0,0 +1,369 @@
+
+/*
+ * Copyright (C) Xiaozhe Wang (chaoslawful)
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef DDEBUG
+#define DDEBUG 0
+#endif
+#include "ddebug.h"
+
+
+#include "ngx_http_lua_contentby.h"
+#include "ngx_http_lua_util.h"
+#include "ngx_http_lua_exception.h"
+#include "ngx_http_lua_cache.h"
+#include "ngx_http_lua_probe.h"
+
+
+static void ngx_http_lua_content_phase_post_read(ngx_http_request_t *r);
+
+
+ngx_int_t
+ngx_http_lua_content_by_chunk(lua_State *L, ngx_http_request_t *r)
+{
+    int                      co_ref;
+    ngx_int_t                rc;
+    lua_State               *co;
+    ngx_http_lua_ctx_t      *ctx;
+    ngx_http_cleanup_t      *cln;
+
+    ngx_http_lua_loc_conf_t      *llcf;
+
+    dd("content by chunk");
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
+
+    if (ctx == NULL) {
+        ctx = ngx_http_lua_create_ctx(r);
+        if (ctx == NULL) {
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+        }
+
+    } else {
+        dd("reset ctx");
+        ngx_http_lua_reset_ctx(r, L, ctx);
+    }
+
+    ctx->entered_content_phase = 1;
+
+    /*  {{{ new coroutine to handle request */
+    co = ngx_http_lua_new_thread(r, L, &co_ref);
+
+    if (co == NULL) {
+        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
+                     "lua: failed to create new coroutine to handle request");
+
+        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+    }
+
+    /*  move code closure to new coroutine */
+    lua_xmove(L, co, 1);
+
+    /*  set closure's env table to new coroutine's globals table */
+    ngx_http_lua_get_globals_table(co);
+    lua_setfenv(co, -2);
+
+    /*  save nginx request in coroutine globals table */
+    ngx_http_lua_set_req(co, r);
+
+    ctx->cur_co_ctx = &ctx->entry_co_ctx;
+    ctx->cur_co_ctx->co = co;
+    ctx->cur_co_ctx->co_ref = co_ref;
+#ifdef NGX_LUA_USE_ASSERT
+    ctx->cur_co_ctx->co_top = 1;
+#endif
+
+    /*  {{{ register request cleanup hooks */
+    if (ctx->cleanup == NULL) {
+        cln = ngx_http_cleanup_add(r, 0);
+        if (cln == NULL) {
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+        }
+
+        cln->handler = ngx_http_lua_request_cleanup_handler;
+        cln->data = ctx;
+        ctx->cleanup = &cln->handler;
+    }
+    /*  }}} */
+
+    ctx->context = NGX_HTTP_LUA_CONTEXT_CONTENT;
+
+    llcf = ngx_http_get_module_loc_conf(r, ngx_http_lua_module);
+
+    if (llcf->check_client_abort) {
+        r->read_event_handler = ngx_http_lua_rd_check_broken_connection;
+
+    } else {
+        r->read_event_handler = ngx_http_block_reading;
+    }
+
+    rc = ngx_http_lua_run_thread(L, r, ctx, 0);
+
+    if (rc == NGX_ERROR || rc >= NGX_OK) {
+        return rc;
+    }
+
+    if (rc == NGX_AGAIN) {
+        return ngx_http_lua_content_run_posted_threads(L, r, ctx, 0);
+    }
+
+    if (rc == NGX_DONE) {
+        return ngx_http_lua_content_run_posted_threads(L, r, ctx, 1);
+    }
+
+    return NGX_OK;
+}
+
+
+void
+ngx_http_lua_content_wev_handler(ngx_http_request_t *r)
+{
+    ngx_http_lua_ctx_t          *ctx;
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
+    if (ctx == NULL) {
+        return;
+    }
+
+    (void) ctx->resume_handler(r);
+}
+
+
+ngx_int_t
+ngx_http_lua_content_handler(ngx_http_request_t *r)
+{
+    ngx_http_lua_loc_conf_t     *llcf;
+    ngx_http_lua_ctx_t          *ctx;
+    ngx_int_t                    rc;
+
+    ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   "lua content handler, uri:\"%V\" c:%ud", &r->uri,
+                   r->main->count);
+
+    llcf = ngx_http_get_module_loc_conf(r, ngx_http_lua_module);
+
+    if (llcf->content_handler == NULL) {
+        dd("no content handler found");
+        return NGX_DECLINED;
+    }
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
+
+    dd("ctx = %p", ctx);
+
+    if (ctx == NULL) {
+        ctx = ngx_http_lua_create_ctx(r);
+        if (ctx == NULL) {
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+        }
+    }
+
+    dd("entered? %d", (int) ctx->entered_content_phase);
+
+    if (ctx->waiting_more_body) {
+        return NGX_DONE;
+    }
+
+    if (ctx->entered_content_phase) {
+        dd("calling wev handler");
+        rc = ctx->resume_handler(r);
+        dd("wev handler returns %d", (int) rc);
+        return rc;
+    }
+
+    if (llcf->force_read_body && !ctx->read_body_done) {
+        r->request_body_in_single_buf = 1;
+        r->request_body_in_persistent_file = 1;
+        r->request_body_in_clean_file = 1;
+
+        rc = ngx_http_read_client_request_body(r,
+                                        ngx_http_lua_content_phase_post_read);
+
+        if (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE) {
+#if (nginx_version < 1002006) ||                                             \
+        (nginx_version >= 1003000 && nginx_version < 1003009)
+            r->main->count--;
+#endif
+            return rc;
+        }
+
+        if (rc == NGX_AGAIN) {
+            ctx->waiting_more_body = 1;
+
+            return NGX_DONE;
+        }
+    }
+
+    dd("setting entered");
+
+    ctx->entered_content_phase = 1;
+
+    dd("calling content handler");
+    return llcf->content_handler(r);
+}
+
+
+/* post read callback for the content phase */
+static void
+ngx_http_lua_content_phase_post_read(ngx_http_request_t *r)
+{
+    ngx_http_lua_ctx_t  *ctx;
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module);
+
+    ctx->read_body_done = 1;
+
+    if (ctx->waiting_more_body) {
+        ctx->waiting_more_body = 0;
+        ngx_http_lua_finalize_request(r, ngx_http_lua_content_handler(r));
+
+    } else {
+        r->main->count--;
+    }
+}
+
+
+ngx_int_t
+ngx_http_lua_content_handler_file(ngx_http_request_t *r)
+{
+    lua_State                       *L;
+    ngx_int_t                        rc;
+    u_char                          *script_path;
+    ngx_http_lua_loc_conf_t         *llcf;
+    ngx_str_t                        eval_src;
+
+    llcf = ngx_http_get_module_loc_conf(r, ngx_http_lua_module);
+
+    if (ngx_http_complex_value(r, &llcf->content_src, &eval_src) != NGX_OK) {
+        return NGX_ERROR;
+    }
+
+    script_path = ngx_http_lua_rebase_path(r->pool, eval_src.data,
+                                           eval_src.len);
+
+    if (script_path == NULL) {
+        return NGX_ERROR;
+    }
+
+    L = ngx_http_lua_get_lua_vm(r, NULL);
+
+    /*  load Lua script file (w/ cache)        sp = 1 */
+    rc = ngx_http_lua_cache_loadfile(r, L, script_path,
+                                     llcf->content_src_key);
+    if (rc != NGX_OK) {
+        if (rc < NGX_HTTP_SPECIAL_RESPONSE) {
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+        }
+
+        return rc;
+    }
+
+    /*  make sure we have a valid code chunk */
+    ngx_http_lua_assert(lua_isfunction(L, -1));
+
+    return ngx_http_lua_content_by_chunk(L, r);
+}
+
+
+ngx_int_t
+ngx_http_lua_content_handler_inline(ngx_http_request_t *r)
+{
+    lua_State                   *L;
+    ngx_int_t                    rc;
+    ngx_http_lua_loc_conf_t     *llcf;
+
+    llcf = ngx_http_get_module_loc_conf(r, ngx_http_lua_module);
+
+    L = ngx_http_lua_get_lua_vm(r, NULL);
+
+    /*  load Lua inline script (w/ cache) sp = 1 */
+    rc = ngx_http_lua_cache_loadbuffer(r, L, llcf->content_src.value.data,
+                                       llcf->content_src.value.len,
+                                       llcf->content_src_key,
+                                       (const char *)
+                                       llcf->content_chunkname);
+    if (rc != NGX_OK) {
+        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+    }
+
+    return ngx_http_lua_content_by_chunk(L, r);
+}
+
+
+ngx_int_t
+ngx_http_lua_content_run_posted_threads(lua_State *L, ngx_http_request_t *r,
+    ngx_http_lua_ctx_t *ctx, int n)
+{
+    ngx_int_t                        rc;
+    ngx_http_lua_posted_thread_t    *pt;
+
+    dd("run posted threads: %p", ctx->posted_threads);
+
+    for ( ;; ) {
+        pt = ctx->posted_threads;
+        if (pt == NULL) {
+            goto done;
+        }
+
+        ctx->posted_threads = pt->next;
+
+        ngx_http_lua_probe_run_posted_thread(r, pt->co_ctx->co,
+                                             (int) pt->co_ctx->co_status);
+
+        dd("posted thread status: %d", pt->co_ctx->co_status);
+
+        if (pt->co_ctx->co_status != NGX_HTTP_LUA_CO_RUNNING) {
+            continue;
+        }
+
+        ctx->cur_co_ctx = pt->co_ctx;
+
+        rc = ngx_http_lua_run_thread(L, r, ctx, 0);
+
+        if (rc == NGX_AGAIN) {
+            continue;
+        }
+
+        if (rc == NGX_DONE) {
+            n++;
+            continue;
+        }
+
+        if (rc == NGX_OK) {
+            while (n > 0) {
+                ngx_http_lua_finalize_request(r, NGX_DONE);
+                n--;
+            }
+
+            return NGX_OK;
+        }
+
+        /* rc == NGX_ERROR || rc > NGX_OK */
+
+        return rc;
+    }
+
+done:
+
+    if (n == 1) {
+        return NGX_DONE;
+    }
+
+    if (n == 0) {
+        r->main->count++;
+        return NGX_DONE;
+    }
+
+    /* n > 1 */
+
+    do {
+        ngx_http_lua_finalize_request(r, NGX_DONE);
+    } while (--n > 1);
+
+    return NGX_DONE;
+}
+
+/* vi:set ft=c ts=4 sw=4 et fdm=marker: */