passenger 4.0.59 → 4.0.60

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

@@ -0,0 +1,23 @@
+
+/*
+ * Copyright (C) Xiaozhe Wang (chaoslawful)
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef _NGX_HTTP_LUA_HEADERS_OUT_H_INCLUDED_
+#define _NGX_HTTP_LUA_HEADERS_OUT_H_INCLUDED_
+
+
+#include "ngx_http_lua_common.h"
+
+
+ngx_int_t ngx_http_lua_set_output_header(ngx_http_request_t *r, ngx_str_t key,
+    ngx_str_t value, unsigned override);
+int ngx_http_lua_get_output_header(lua_State *L, ngx_http_request_t *r,
+    ngx_str_t *key);
+
+
+#endif /* _NGX_HTTP_LUA_HEADERS_OUT_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_initby.c

@@ -0,0 +1,42 @@
+
+/*
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef DDEBUG
+#define DDEBUG 0
+#endif
+
+#include "ddebug.h"
+#include "ngx_http_lua_initby.h"
+#include "ngx_http_lua_util.h"
+
+
+ngx_int_t
+ngx_http_lua_init_by_inline(ngx_log_t *log, ngx_http_lua_main_conf_t *lmcf,
+    lua_State *L)
+{
+    int         status;
+
+    status = luaL_loadbuffer(L, (char *) lmcf->init_src.data,
+                             lmcf->init_src.len, "=init_by_lua")
+             || ngx_http_lua_do_call(log, L);
+
+    return ngx_http_lua_report(log, L, status, "init_by_lua");
+}
+
+
+ngx_int_t
+ngx_http_lua_init_by_file(ngx_log_t *log, ngx_http_lua_main_conf_t *lmcf,
+    lua_State *L)
+{
+    int         status;
+
+    status = luaL_loadfile(L, (char *) lmcf->init_src.data)
+             || ngx_http_lua_do_call(log, L);
+
+    return ngx_http_lua_report(log, L, status, "init_by_lua_file");
+}
+
+/* vi:set ft=c ts=4 sw=4 et fdm=marker: */

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

@@ -0,0 +1,23 @@
+
+/*
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef _NGX_HTTP_LUA_INITBY_H_INCLUDED_
+#define _NGX_HTTP_LUA_INITBY_H_INCLUDED_
+
+
+#include "ngx_http_lua_common.h"
+
+
+ngx_int_t ngx_http_lua_init_by_inline(ngx_log_t *log,
+    ngx_http_lua_main_conf_t *lmcf, lua_State *L);
+
+ngx_int_t ngx_http_lua_init_by_file(ngx_log_t *log,
+    ngx_http_lua_main_conf_t *lmcf, lua_State *L);
+
+
+#endif /* _NGX_HTTP_LUA_INITBY_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_initworkerby.c

@@ -0,0 +1,320 @@
+
+/*
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef DDEBUG
+#define DDEBUG 0
+#endif
+#include "ddebug.h"
+
+
+#include "ngx_http_lua_initworkerby.h"
+#include "ngx_http_lua_util.h"
+
+
+static u_char * ngx_http_lua_log_init_worker_error(ngx_log_t *log,
+    u_char *buf, size_t len);
+
+
+ngx_int_t
+ngx_http_lua_init_worker(ngx_cycle_t *cycle)
+{
+    char                        *rv;
+    void                        *cur, *prev;
+    ngx_uint_t                   i;
+    ngx_conf_t                   conf;
+    ngx_cycle_t                 *fake_cycle;
+    ngx_open_file_t             *file, *ofile;
+    ngx_list_part_t             *part;
+    ngx_connection_t            *c = NULL;
+    ngx_http_module_t           *module;
+    ngx_http_request_t          *r = NULL;
+    ngx_http_lua_ctx_t          *ctx;
+    ngx_http_conf_ctx_t         *conf_ctx, http_ctx;
+    ngx_http_lua_loc_conf_t     *llcf, *top_llcf;
+    ngx_http_lua_main_conf_t    *lmcf;
+    ngx_http_core_loc_conf_t    *clcf, *top_clcf;
+
+    lmcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_lua_module);
+
+    if (lmcf == NULL
+        || lmcf->init_worker_handler == NULL
+        || lmcf->lua == NULL)
+    {
+        return NGX_OK;
+    }
+
+    conf_ctx = ((ngx_http_conf_ctx_t *) cycle->conf_ctx[ngx_http_module.index]);
+    http_ctx.main_conf = conf_ctx->main_conf;
+
+    top_clcf = conf_ctx->loc_conf[ngx_http_core_module.ctx_index];
+    top_llcf = conf_ctx->loc_conf[ngx_http_lua_module.ctx_index];
+
+    ngx_memzero(&conf, sizeof(ngx_conf_t));
+
+    conf.temp_pool = ngx_create_pool(NGX_CYCLE_POOL_SIZE, cycle->log);
+    if (conf.temp_pool == NULL) {
+        return NGX_ERROR;
+    }
+
+    conf.temp_pool->log = cycle->log;
+
+    /* we fake a temporary ngx_cycle_t here because some
+     * modules' merge conf handler may produce side effects in
+     * cf->cycle (like ngx_proxy vs cf->cycle->paths).
+     * also, we cannot allocate our temp cycle on the stack
+     * because some modules like ngx_http_core_module reference
+     * addresses within cf->cycle (i.e., via "&cf->cycle->new_log")
+     */
+
+    fake_cycle = ngx_palloc(cycle->pool, sizeof(ngx_cycle_t));
+    if (fake_cycle == NULL) {
+        goto failed;
+    }
+
+    ngx_memcpy(fake_cycle, cycle, sizeof(ngx_cycle_t));
+
+#if defined(nginx_version) && nginx_version >= 9007
+
+    ngx_queue_init(&fake_cycle->reusable_connections_queue);
+
+#endif
+
+    if (ngx_array_init(&fake_cycle->listening, cycle->pool,
+                       cycle->listening.nelts || 1,
+                       sizeof(ngx_listening_t))
+        != NGX_OK)
+    {
+        goto failed;
+    }
+
+#if defined(nginx_version) && nginx_version >= 1003007
+
+    if (ngx_array_init(&fake_cycle->paths, cycle->pool, cycle->paths.nelts || 1,
+                       sizeof(ngx_path_t *))
+        != NGX_OK)
+    {
+        goto failed;
+    }
+
+#endif
+
+    part = &cycle->open_files.part;
+    ofile = part->elts;
+
+    if (ngx_list_init(&fake_cycle->open_files, cycle->pool, part->nelts || 1,
+                      sizeof(ngx_open_file_t))
+        != NGX_OK)
+    {
+        goto failed;
+    }
+
+    for (i = 0; /* void */ ; i++) {
+
+        if (i >= part->nelts) {
+            if (part->next == NULL) {
+                break;
+            }
+            part = part->next;
+            ofile = part->elts;
+            i = 0;
+        }
+
+        file = ngx_list_push(&fake_cycle->open_files);
+        if (file == NULL) {
+            goto failed;
+        }
+
+        ngx_memcpy(file, ofile, sizeof(ngx_open_file_t));
+    }
+
+    if (ngx_list_init(&fake_cycle->shared_memory, cycle->pool, 1,
+                      sizeof(ngx_shm_zone_t))
+        != NGX_OK)
+    {
+        goto failed;
+    }
+
+    conf.ctx = &http_ctx;
+    conf.cycle = fake_cycle;
+    conf.pool = fake_cycle->pool;
+    conf.log = cycle->log;
+
+    http_ctx.loc_conf = ngx_pcalloc(conf.pool,
+                                    sizeof(void *) * ngx_http_max_module);
+    if (http_ctx.loc_conf == NULL) {
+        return NGX_ERROR;
+    }
+
+    http_ctx.srv_conf = ngx_pcalloc(conf.pool,
+                                    sizeof(void *) * ngx_http_max_module);
+    if (http_ctx.srv_conf == NULL) {
+        return NGX_ERROR;
+    }
+
+    for (i = 0; ngx_modules[i]; i++) {
+        if (ngx_modules[i]->type != NGX_HTTP_MODULE) {
+            continue;
+        }
+
+        module = ngx_modules[i]->ctx;
+
+        if (module->create_srv_conf) {
+            cur = module->create_srv_conf(&conf);
+            if (cur == NULL) {
+                return NGX_ERROR;
+            }
+
+            if (module->merge_srv_conf) {
+                prev = module->create_srv_conf(&conf);
+                if (prev == NULL) {
+                    return NGX_ERROR;
+                }
+
+                rv = module->merge_srv_conf(&conf, prev, cur);
+                if (rv != NGX_CONF_OK) {
+                    goto failed;
+                }
+            }
+
+            http_ctx.srv_conf[ngx_modules[i]->ctx_index] = cur;
+        }
+
+        if (module->create_loc_conf) {
+            cur = module->create_loc_conf(&conf);
+            if (cur == NULL) {
+                return NGX_ERROR;
+            }
+
+            if (module->merge_loc_conf) {
+                prev = module->create_loc_conf(&conf);
+                if (prev == NULL) {
+                    return NGX_ERROR;
+                }
+
+                rv = module->merge_loc_conf(&conf, prev, cur);
+                if (rv != NGX_CONF_OK) {
+                    goto failed;
+                }
+            }
+
+            http_ctx.loc_conf[ngx_modules[i]->ctx_index] = cur;
+        }
+    }
+
+    ngx_destroy_pool(conf.temp_pool);
+    conf.temp_pool = NULL;
+
+    c = ngx_http_lua_create_fake_connection(NULL);
+    if (c == NULL) {
+        goto failed;
+    }
+
+    c->log->handler = ngx_http_lua_log_init_worker_error;
+
+    r = ngx_http_lua_create_fake_request(c);
+    if (r == NULL) {
+        goto failed;
+    }
+
+    r->main_conf = http_ctx.main_conf;
+    r->srv_conf = http_ctx.srv_conf;
+    r->loc_conf = http_ctx.loc_conf;
+
+    clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+
+#if defined(nginx_version) && nginx_version >= 1003014
+
+    ngx_http_set_connection_log(r->connection, clcf->error_log);
+
+#else
+
+    c->log->file = clcf->error_log->file;
+
+    if (!(c->log->log_level & NGX_LOG_DEBUG_CONNECTION)) {
+        c->log->log_level = clcf->error_log->log_level;
+    }
+
+#endif
+
+    if (top_clcf->resolver) {
+        clcf->resolver = top_clcf->resolver;
+    }
+
+    ctx = ngx_http_lua_create_ctx(r);
+    if (ctx == NULL) {
+        goto failed;
+    }
+
+    ctx->context = NGX_HTTP_LUA_CONTEXT_INIT_WORKER;
+    ctx->cur_co_ctx = NULL;
+    r->read_event_handler = ngx_http_block_reading;
+
+    llcf = ngx_http_get_module_loc_conf(r, ngx_http_lua_module);
+    if (top_llcf->log_socket_errors != NGX_CONF_UNSET) {
+        llcf->log_socket_errors = top_llcf->log_socket_errors;
+    }
+
+    ngx_http_lua_set_req(lmcf->lua, r);
+
+    (void) lmcf->init_worker_handler(cycle->log, lmcf, lmcf->lua);
+
+    ngx_destroy_pool(c->pool);
+    return NGX_OK;
+
+failed:
+
+    if (conf.temp_pool) {
+        ngx_destroy_pool(conf.temp_pool);
+    }
+
+    if (c) {
+        ngx_http_lua_close_fake_connection(c);
+    }
+
+    return NGX_ERROR;
+}
+
+
+ngx_int_t
+ngx_http_lua_init_worker_by_inline(ngx_log_t *log,
+    ngx_http_lua_main_conf_t *lmcf, lua_State *L)
+{
+    int         status;
+
+    status = luaL_loadbuffer(L, (char *) lmcf->init_worker_src.data,
+                             lmcf->init_worker_src.len, "=init_worker_by_lua")
+             || ngx_http_lua_do_call(log, L);
+
+    return ngx_http_lua_report(log, L, status, "init_worker_by_lua");
+}
+
+
+ngx_int_t
+ngx_http_lua_init_worker_by_file(ngx_log_t *log, ngx_http_lua_main_conf_t *lmcf,
+    lua_State *L)
+{
+    int         status;
+
+    status = luaL_loadfile(L, (char *) lmcf->init_worker_src.data)
+             || ngx_http_lua_do_call(log, L);
+
+    return ngx_http_lua_report(log, L, status, "init_worker_by_lua_file");
+}
+
+
+static u_char *
+ngx_http_lua_log_init_worker_error(ngx_log_t *log, u_char *buf, size_t len)
+{
+    u_char              *p;
+
+    if (log->action) {
+        p = ngx_snprintf(buf, len, " while %s", log->action);
+        len -= p - buf;
+        buf = p;
+    }
+
+    return ngx_snprintf(buf, len, ", context: init_worker_by_lua*");
+}

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

@@ -0,0 +1,25 @@
+
+/*
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef _NGX_HTTP_LUA_INITWORKERBY_H_INCLUDED_
+#define _NGX_HTTP_LUA_INITWORKERBY_H_INCLUDED_
+
+
+#include "ngx_http_lua_common.h"
+
+
+ngx_int_t ngx_http_lua_init_worker_by_inline(ngx_log_t *log,
+    ngx_http_lua_main_conf_t *lmcf, lua_State *L);
+
+ngx_int_t ngx_http_lua_init_worker_by_file(ngx_log_t *log,
+    ngx_http_lua_main_conf_t *lmcf, lua_State *L);
+
+ngx_int_t ngx_http_lua_init_worker(ngx_cycle_t *cycle);
+
+
+#endif /* _NGX_HTTP_LUA_INITWORKERBY_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_log.c

@@ -0,0 +1,300 @@
+
+/*
+ * Copyright (C) Xiaozhe Wang (chaoslawful)
+ * Copyright (C) Yichun Zhang (agentzh)
+ */
+
+
+#ifndef DDEBUG
+#define DDEBUG 0
+#endif
+#include "ddebug.h"
+
+
+#include "ngx_http_lua_log.h"
+#include "ngx_http_lua_util.h"
+
+
+static int ngx_http_lua_print(lua_State *L);
+static int ngx_http_lua_ngx_log(lua_State *L);
+static int log_wrapper(ngx_log_t *log, const char *ident,
+    ngx_uint_t level, lua_State *L);
+static void ngx_http_lua_inject_log_consts(lua_State *L);
+
+
+/**
+ * Wrapper of nginx log functionality. Take a log level param and varargs of
+ * log message params.
+ *
+ * @param L Lua state pointer
+ * @retval always 0 (don't return values to Lua)
+ * */
+int
+ngx_http_lua_ngx_log(lua_State *L)
+{
+    ngx_log_t                   *log;
+    ngx_http_request_t          *r;
+    const char                  *msg;
+    int                          level;
+
+    r = ngx_http_lua_get_req(L);
+
+    if (r && r->connection && r->connection->log) {
+        log = r->connection->log;
+
+    } else {
+        log = ngx_cycle->log;
+    }
+
+    level = luaL_checkint(L, 1);
+    if (level < NGX_LOG_STDERR || level > NGX_LOG_DEBUG) {
+        msg = lua_pushfstring(L, "bad log level: %d", level);
+        return luaL_argerror(L, 1, msg);
+    }
+
+    /* remove log-level param from stack */
+    lua_remove(L, 1);
+
+    return log_wrapper(log, "[lua] ", (ngx_uint_t) level, L);
+}
+
+
+/**
+ * Override Lua print function, output message to nginx error logs. Equal to
+ * ngx.log(ngx.NOTICE, ...).
+ *
+ * @param L Lua state pointer
+ * @retval always 0 (don't return values to Lua)
+ * */
+int
+ngx_http_lua_print(lua_State *L)
+{
+    ngx_log_t                   *log;
+    ngx_http_request_t          *r;
+
+    r = ngx_http_lua_get_req(L);
+
+    if (r && r->connection && r->connection->log) {
+        log = r->connection->log;
+
+    } else {
+        log = ngx_cycle->log;
+    }
+
+    return log_wrapper(log, "[lua] ", NGX_LOG_NOTICE, L);
+}
+
+
+static int
+log_wrapper(ngx_log_t *log, const char *ident, ngx_uint_t level,
+    lua_State *L)
+{
+    u_char              *buf;
+    u_char              *p, *q;
+    ngx_str_t            name;
+    int                  nargs, i;
+    size_t               size, len;
+    size_t               src_len = 0;
+    int                  type;
+    const char          *msg;
+    lua_Debug            ar;
+
+    if (level > log->log_level) {
+        return 0;
+    }
+
+#if 1
+    /* add debug info */
+
+    lua_getstack(L, 1, &ar);
+    lua_getinfo(L, "Snl", &ar);
+
+    /* get the basename of the Lua source file path, stored in q */
+    name.data = (u_char *) ar.short_src;
+    if (name.data == NULL) {
+        name.len = 0;
+
+    } else {
+        p = name.data;
+        while (*p != '\0') {
+            if (*p == '/' || *p == '\\') {
+                name.data = p + 1;
+            }
+            p++;
+        }
+
+        name.len = p - name.data;
+    }
+
+#endif
+
+    nargs = lua_gettop(L);
+
+    size = name.len + NGX_INT_T_LEN + sizeof(":: ") - 1;
+
+    if (*ar.namewhat != '\0' && *ar.what == 'L') {
+        src_len = ngx_strlen(ar.name);
+        size += src_len + sizeof("(): ") - 1;
+    }
+
+    for (i = 1; i <= nargs; i++) {
+        type = lua_type(L, i);
+        switch (type) {
+            case LUA_TNUMBER:
+            case LUA_TSTRING:
+                lua_tolstring(L, i, &len);
+                size += len;
+                break;
+
+            case LUA_TNIL:
+                size += sizeof("nil") - 1;
+                break;
+
+            case LUA_TBOOLEAN:
+                if (lua_toboolean(L, i)) {
+                    size += sizeof("true") - 1;
+
+                } else {
+                    size += sizeof("false") - 1;
+                }
+
+                break;
+
+            case LUA_TLIGHTUSERDATA:
+                if (lua_touserdata(L, i) == NULL) {
+                    size += sizeof("null") - 1;
+                    break;
+                }
+
+                continue;
+
+            default:
+                msg = lua_pushfstring(L, "string, number, boolean, or nil "
+                                      "expected, got %s",
+                                      lua_typename(L, type));
+                return luaL_argerror(L, i, msg);
+        }
+    }
+
+    buf = lua_newuserdata(L, size);
+
+    p = ngx_copy(buf, name.data, name.len);
+
+    *p++ = ':';
+
+    p = ngx_snprintf(p, NGX_INT_T_LEN, "%d",
+                     ar.currentline ? ar.currentline : ar.linedefined);
+
+    *p++ = ':'; *p++ = ' ';
+
+    if (*ar.namewhat != '\0' && *ar.what == 'L') {
+        p = ngx_copy(p, ar.name, src_len);
+        *p++ = '(';
+        *p++ = ')';
+        *p++ = ':';
+        *p++ = ' ';
+    }
+
+    for (i = 1; i <= nargs; i++) {
+        type = lua_type(L, i);
+        switch (type) {
+            case LUA_TNUMBER:
+            case LUA_TSTRING:
+                q = (u_char *) lua_tolstring(L, i, &len);
+                p = ngx_copy(p, q, len);
+                break;
+
+            case LUA_TNIL:
+                *p++ = 'n';
+                *p++ = 'i';
+                *p++ = 'l';
+                break;
+
+            case LUA_TBOOLEAN:
+                if (lua_toboolean(L, i)) {
+                    *p++ = 't';
+                    *p++ = 'r';
+                    *p++ = 'u';
+                    *p++ = 'e';
+
+                } else {
+                    *p++ = 'f';
+                    *p++ = 'a';
+                    *p++ = 'l';
+                    *p++ = 's';
+                    *p++ = 'e';
+                }
+
+                break;
+
+            case LUA_TLIGHTUSERDATA:
+                *p++ = 'n';
+                *p++ = 'u';
+                *p++ = 'l';
+                *p++ = 'l';
+
+                break;
+
+            default:
+                return luaL_error(L, "impossible to reach here");
+        }
+    }
+
+    if (p - buf > (off_t) size) {
+        return luaL_error(L, "buffer error: %d > %d", (int) (p - buf),
+                          (int) size);
+    }
+
+    ngx_log_error(level, log, 0, "%s%*s", ident, (size_t) (p - buf), buf);
+
+    return 0;
+}
+
+
+void
+ngx_http_lua_inject_log_api(lua_State *L)
+{
+    ngx_http_lua_inject_log_consts(L);
+
+    lua_pushcfunction(L, ngx_http_lua_ngx_log);
+    lua_setfield(L, -2, "log");
+
+    lua_pushcfunction(L, ngx_http_lua_print);
+    lua_setglobal(L, "print");
+}
+
+
+static void
+ngx_http_lua_inject_log_consts(lua_State *L)
+{
+    /* {{{ nginx log level constants */
+    lua_pushinteger(L, NGX_LOG_STDERR);
+    lua_setfield(L, -2, "STDERR");
+
+    lua_pushinteger(L, NGX_LOG_EMERG);
+    lua_setfield(L, -2, "EMERG");
+
+    lua_pushinteger(L, NGX_LOG_ALERT);
+    lua_setfield(L, -2, "ALERT");
+
+    lua_pushinteger(L, NGX_LOG_CRIT);
+    lua_setfield(L, -2, "CRIT");
+
+    lua_pushinteger(L, NGX_LOG_ERR);
+    lua_setfield(L, -2, "ERR");
+
+    lua_pushinteger(L, NGX_LOG_WARN);
+    lua_setfield(L, -2, "WARN");
+
+    lua_pushinteger(L, NGX_LOG_NOTICE);
+    lua_setfield(L, -2, "NOTICE");
+
+    lua_pushinteger(L, NGX_LOG_INFO);
+    lua_setfield(L, -2, "INFO");
+
+    lua_pushinteger(L, NGX_LOG_DEBUG);
+    lua_setfield(L, -2, "DEBUG");
+    /* }}} */
+}
+
+/* vi:set ft=c ts=4 sw=4 et fdm=marker: */