bugfix: applied the patch for nginx security advisory (CVE-2016-4450).

also bumped version to 1.9.7.5.

.gitignore

@@ -66,6 +66,7 @@ util/blog-rows.sql
 util/comments.sql
 util/posts.sql
 ngx_openresty-*
+openresty-*
 work/
 reindex
 t/*.t_

Makefile

@@ -7,8 +7,8 @@ test: all
 	prove -r t
 
 try-luajit: all
-	cd ngx_openresty-`./util/ver` && ./configure --with-luajit
+	cd openresty-`./util/ver` && ./configure --with-luajit
 
 try-lua: all
-	cd ngx_openresty-`./util/ver` && ./configure && $(MAKE)
+	cd openresty-`./util/ver` && ./configure && $(MAKE)
 

README.markdown

@@ -1,7 +1,7 @@
 Name
 ====
 
-ngx_openresty - Turning Nginx into a Full-Fledged Scriptable Web Platform
+OpenResty - Turning Nginx into a Full-Fledged Scriptable Web Platform
 
 Table of Contents
 =================
@@ -17,7 +17,7 @@ Table of Contents
 Description
 ===========
 
-ngx_openresty is a full-fledged web application server by bundling the standard nginx core,
+OpenResty is a full-fledged web application server by bundling the standard nginx core,
 lots of 3rd-party nginx modules, as well as most of their external dependencies.
 
 This bundle is maintained Yichun Zhang (agentzh).
@@ -40,7 +40,7 @@ For Bundle Maintainers
 
 The bundle's source is at the following git repository:
 
-https://github.com/openresty/ngx_openresty
+https://github.com/openresty/openresty
 
 To reproduce the bundle tarball, just do
 
@@ -79,7 +79,7 @@ Report Bugs
 
 You're very welcome to report issues on GitHub:
 
-https://github.com/agentzh/ngx_openresty/issues
+https://github.com/openresty/openresty/issues
 
 [Back to TOC](#table-of-contents)
 
@@ -88,7 +88,7 @@ Copyright & License
 
 The bundle itself is licensed under the 2-clause BSD license.
 
-Copyright (c) 2011-2015, Yichun "agentzh" Zhang (章亦春) <agentzh@gmail.com>, CloudFlare Inc.
+Copyright (c) 2011-2016, Yichun "agentzh" Zhang (章亦春) <agentzh@gmail.com>, CloudFlare Inc.
 
 This module is licensed under the terms of the BSD license.
 

demo/Blog/template/sidebar.tt

@@ -73,7 +73,7 @@
                 <a href="site-binary.tar.gz">Compiled form (.tar.gz)</a>
             </li>
             <li class="module-list-item">
-                <a target="_blank" href="http://github.com/agentzh/ngx_openresty/tree/master/demo/[% blog_owner == 'agentzh' ? "Blog" : "Blog2" %]/">
+                <a target="_blank" href="http://github.com/openresty/openresty/tree/master/demo/[% blog_owner == 'agentzh' ? "Blog" : "Blog2" %]/">
                     Source code (Git)
                 </a>
             </li>

doc/README-win32.md

@@ -150,10 +150,10 @@ make install
 where the dependency library source tarballs for OpenSSL, Zlib, and PCRE are downloaded
 from their official sites, respectively.
 
-We automate these commands in a dedicated shell script named [build-win32.sh](https://github.com/openresty/ngx_openresty/blob/master/util/build-win32.sh).
+We automate these commands in a dedicated shell script named [build-win32.sh](https://github.com/openresty/openresty/blob/master/util/build-win32.sh).
 
 Furthermore, we automate the packaging process of the resulting binaries and supporting files
-with this [package-win32.sh](https://github.com/openresty/ngx_openresty/blob/master/util/package-win32.sh)
+with this [package-win32.sh](https://github.com/openresty/openresty/blob/master/util/package-win32.sh)
 script.
 
 Usually you can just download and use the binary distribution of OpenResty without

patches/nginx-1.9.11-always_enable_cc_feature_tests.patch

@@ -0,0 +1,11 @@
+--- nginx-1.9.11/auto/cc/conf	2015-10-30 22:47:50.000000000 +0800
++++ nginx-1.9.11-patched/auto/cc/conf	2015-11-02 12:23:05.385156987 +0800
+@@ -136,7 +136,7 @@ fi
+ CFLAGS="$CFLAGS $NGX_CC_OPT"
+ NGX_TEST_LD_OPT="$NGX_LD_OPT"
+ 
+-if [ "$NGX_PLATFORM" != win32 ]; then
++if [ 1 ]; then
+ 
+     if test -n "$NGX_LD_OPT"; then
+         ngx_feature=--with-ld-opt=\"$NGX_LD_OPT\"

patches/nginx-1.9.11-cache_manager_exit.patch

@@ -0,0 +1,19 @@
+# HG changeset patch
+# User Yichun Zhang <agentzh@gmail.com>
+# Date 1383598130 28800
+# Node ID f64218e1ac963337d84092536f588b8e0d99bbaa
+# Parent  dea321e5c0216efccbb23e84bbce7cf3e28f130c
+Cache: gracefully exit the cache manager process.
+
+diff -r dea321e5c021 -r f64218e1ac96 src/os/unix/ngx_process_cycle.c
+--- a/src/os/unix/ngx_process_cycle.c	Thu Oct 31 18:23:49 2013 +0400
++++ b/src/os/unix/ngx_process_cycle.c	Mon Nov 04 12:48:50 2013 -0800
+@@ -1335,7 +1335,7 @@
+ 
+         if (ngx_terminate || ngx_quit) {
+             ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
+-            exit(0);
++            ngx_worker_process_exit(cycle);
+         }
+ 
+         if (ngx_reopen) {

patches/nginx-1.9.11-gcc-maybe-uninitialized-warning.patch

@@ -0,0 +1,11 @@
+--- nginx-1.9.11/src/http/ngx_http_request.c	2013-05-06 03:26:50.000000000 -0700
++++ nginx-1.9.11-patched/src/http/ngx_http_request.c	2013-06-11 12:59:48.008321688 -0700
+@@ -1951,7 +1951,7 @@
+     ngx_int_t                  rc;
+     ngx_http_connection_t     *hc;
+     ngx_http_core_loc_conf_t  *clcf;
+-    ngx_http_core_srv_conf_t  *cscf;
++    ngx_http_core_srv_conf_t  *cscf = NULL;
+ 
+     hc = r->http_connection;
+ 

patches/nginx-1.9.11-hash_overflow.patch

@@ -0,0 +1,20 @@
+# HG changeset patch
+# User Yichun Zhang <agentzh@gmail.com>
+# Date 1412276417 25200
+#      Thu Oct 02 12:00:17 2014 -0700
+# Node ID 4032b992f23b054c1a2cfb0be879330d2c6708e5
+# Parent  1ff0f68d9376e3d184d65814a6372856bf65cfcd
+Hash: buffer overflow might happen when exceeding the pre-configured limits.
+
+diff -r 1ff0f68d9376 -r 4032b992f23b src/core/ngx_hash.c
+--- a/src/core/ngx_hash.c	Tue Sep 30 15:50:28 2014 -0700
++++ b/src/core/ngx_hash.c	Thu Oct 02 12:00:17 2014 -0700
+@@ -312,6 +312,8 @@ ngx_hash_init(ngx_hash_init_t *hinit, ng
+         continue;
+     }
+ 
++    size--;
++
+     ngx_log_error(NGX_LOG_WARN, hinit->pool->log, 0,
+                   "could not build optimal %s, you should increase "
+                   "either %s_max_size: %i or %s_bucket_size: %i; "

patches/nginx-1.9.11-larger_max_error_str.patch

@@ -0,0 +1,13 @@
+--- nginx-1.9.11/src/core/ngx_log.h	2013-10-08 05:07:14.000000000 -0700
++++ nginx-1.9.11-patched/src/core/ngx_log.h	2013-12-05 20:35:35.996236720 -0800
+@@ -64,7 +64,9 @@ struct ngx_log_s {
+ };
+ 
+ 
+-#define NGX_MAX_ERROR_STR   2048
++#ifndef NGX_MAX_ERROR_STR
++#define NGX_MAX_ERROR_STR   4096
++#endif
+ 
+ 
+ /*********************************/

patches/nginx-1.9.11-log_escape_non_ascii.patch

@@ -0,0 +1,115 @@
+--- nginx-1.9.11/src/http/modules/ngx_http_log_module.c	2011-11-01 21:24:50.000000000 +0800
++++ nginx-1.9.11-patched/src/http/modules/ngx_http_log_module.c	2011-11-10 16:17:29.599039534 +0800
+@@ -61,6 +61,8 @@
+     time_t                      open_file_cache_valid;
+     ngx_uint_t                  open_file_cache_min_uses;
+ 
++    ngx_flag_t                  escape_non_ascii;
++
+     ngx_uint_t                  off;        /* unsigned  off:1 */
+ } ngx_http_log_loc_conf_t;
+ 
+@@ -104,7 +106,8 @@
+     uintptr_t data);
+ static u_char *ngx_http_log_variable(ngx_http_request_t *r, u_char *buf,
+     ngx_http_log_op_t *op);
+-static uintptr_t ngx_http_log_escape(u_char *dst, u_char *src, size_t size);
++static uintptr_t ngx_http_log_escape(ngx_http_log_loc_conf_t *lcf, u_char *dst,
++    u_char *src, size_t size);
+ 
+ 
+ static void *ngx_http_log_create_main_conf(ngx_conf_t *cf);
+@@ -146,6 +149,13 @@
+       0,
+       NULL },
+ 
++    { ngx_string("log_escape_non_ascii"),
++      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
++      ngx_conf_set_flag_slot,
++      NGX_HTTP_LOC_CONF_OFFSET,
++      offsetof(ngx_http_log_loc_conf_t, escape_non_ascii),
++      NULL },
++
+       ngx_null_command
+ };
+ 
+@@ -637,6 +647,7 @@
+ ngx_http_log_variable_getlen(ngx_http_request_t *r, uintptr_t data)
+ {
+     uintptr_t                   len;
++    ngx_http_log_loc_conf_t    *lcf;
+     ngx_http_variable_value_t  *value;
+ 
+     value = ngx_http_get_indexed_variable(r, data);
+@@ -645,7 +656,9 @@
+         return 1;
+     }
+ 
+-    len = ngx_http_log_escape(NULL, value->data, value->len);
++    lcf = ngx_http_get_module_loc_conf(r, ngx_http_log_module);
++
++    len = ngx_http_log_escape(lcf, NULL, value->data, value->len);
+ 
+     value->escape = len ? 1 : 0;
+ 
+@@ -656,6 +669,7 @@
+ static u_char *
+ ngx_http_log_variable(ngx_http_request_t *r, u_char *buf, ngx_http_log_op_t *op)
+ {
++    ngx_http_log_loc_conf_t    *lcf;
+     ngx_http_variable_value_t  *value;
+ 
+     value = ngx_http_get_indexed_variable(r, op->data);
+@@ -669,16 +683,18 @@
+         return ngx_cpymem(buf, value->data, value->len);
+ 
+     } else {
+-        return (u_char *) ngx_http_log_escape(buf, value->data, value->len);
++        lcf = ngx_http_get_module_loc_conf(r, ngx_http_log_module);
++        return (u_char *) ngx_http_log_escape(lcf, buf, value->data, value->len);
+     }
+ }
+ 
+ 
+ static uintptr_t
+-ngx_http_log_escape(u_char *dst, u_char *src, size_t size)
++ngx_http_log_escape(ngx_http_log_loc_conf_t *lcf, u_char *dst, u_char *src,
++    size_t size)
+ {
+-    ngx_uint_t      n;
+-    static u_char   hex[] = "0123456789ABCDEF";
++    ngx_uint_t                   n;
++    static u_char                hex[] = "0123456789ABCDEF";
+ 
+     static uint32_t   escape[] = {
+         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
+@@ -698,6 +714,12 @@
+         0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
+     };
+ 
++    if (lcf->escape_non_ascii) {
++        ngx_memset(&escape[4], 0xff, sizeof(uint32_t) * 4);
++
++    } else {
++        ngx_memzero(&escape[4], sizeof(uint32_t) * 4);
++    }
+ 
+     if (dst == NULL) {
+ 
+@@ -781,6 +803,7 @@
+     }
+ 
+     conf->open_file_cache = NGX_CONF_UNSET_PTR;
++    conf->escape_non_ascii = NGX_CONF_UNSET;
+ 
+     return conf;
+ }
+@@ -796,6 +819,8 @@
+     ngx_http_log_fmt_t        *fmt;
+     ngx_http_log_main_conf_t  *lmcf;
+ 
++    ngx_conf_merge_value(conf->escape_non_ascii, prev->escape_non_ascii, 1);
++
+     if (conf->open_file_cache == NGX_CONF_UNSET_PTR) {
+ 
+         conf->open_file_cache = prev->open_file_cache;

patches/nginx-1.9.11-no_Werror.patch

@@ -0,0 +1,36 @@
+diff -urp nginx-1.9.11/auto/cc/clang nginx-1.9.11-patched/auto/cc/clang
+--- nginx-1.9.11/auto/cc/clang	2014-03-04 03:39:24.000000000 -0800
++++ nginx-1.9.11-patched/auto/cc/clang	2014-03-13 20:54:26.241413360 -0700
+@@ -89,7 +89,7 @@ CFLAGS="$CFLAGS -Wconditional-uninitiali
+ CFLAGS="$CFLAGS -Wno-unused-parameter"
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"
+diff -urp nginx-1.9.11/auto/cc/gcc nginx-1.9.11-patched/auto/cc/gcc
+--- nginx-1.9.11/auto/cc/gcc	2014-03-04 03:39:24.000000000 -0800
++++ nginx-1.9.11-patched/auto/cc/gcc	2014-03-13 20:54:13.301355329 -0700
+@@ -168,7 +168,7 @@ esac
+ 
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"
+diff -urp nginx-1.9.11/auto/cc/icc nginx-1.9.11-patched/auto/cc/icc
+--- nginx-1.9.11/auto/cc/icc	2014-03-04 03:39:24.000000000 -0800
++++ nginx-1.9.11-patched/auto/cc/icc	2014-03-13 20:54:13.301355329 -0700
+@@ -115,7 +115,7 @@ case "$NGX_ICC_VER" in
+ esac
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"

patches/nginx-1.9.11-no_error_pages.patch

@@ -0,0 +1,90 @@
+--- nginx-1.9.11/src/http/ngx_http_core_module.c	2010-12-14 18:38:42.000000000 +0800
++++ nginx-1.9.11-patched/src/http/ngx_http_core_module.c	2011-01-30 19:24:34.956354518 +0800
+@@ -57,6 +57,8 @@
+     void *conf);
+ static char *ngx_http_core_error_page(ngx_conf_t *cf, ngx_command_t *cmd,
+     void *conf);
++static char *ngx_http_core_no_error_pages(ngx_conf_t *cf, ngx_command_t *cmd,
++    void *conf);
+ static char *ngx_http_core_try_files(ngx_conf_t *cf, ngx_command_t *cmd,
+     void *conf);
+ static char *ngx_http_core_open_file_cache(ngx_conf_t *cf, ngx_command_t *cmd,
+@@ -614,6 +616,14 @@
+       0,
+       NULL },
+ 
++    { ngx_string("no_error_pages"),
++      NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
++                        |NGX_CONF_NOARGS,
++      ngx_http_core_no_error_pages,
++      NGX_HTTP_LOC_CONF_OFFSET,
++      0,
++      NULL },
++
+     { ngx_string("try_files"),
+       NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_2MORE,
+       ngx_http_core_try_files,
+@@ -3052,7 +3062,6 @@
+      *     clcf->types = NULL;
+      *     clcf->default_type = { 0, NULL };
+      *     clcf->error_log = NULL;
+-     *     clcf->error_pages = NULL;
+      *     clcf->try_files = NULL;
+      *     clcf->client_body_path = NULL;
+      *     clcf->regex = NULL;
+@@ -3062,6 +3071,7 @@
+      *     clcf->gzip_proxied = 0;
+      */
+ 
++    clcf->error_pages = NGX_CONF_UNSET_PTR;
+     clcf->client_max_body_size = NGX_CONF_UNSET;
+     clcf->client_body_buffer_size = NGX_CONF_UNSET_SIZE;
+     clcf->client_body_timeout = NGX_CONF_UNSET_MSEC;
+@@ -3250,9 +3260,7 @@
+         }
+     }
+ 
+-    if (conf->error_pages == NULL && prev->error_pages) {
+-        conf->error_pages = prev->error_pages;
+-    }
++    ngx_conf_merge_ptr_value(conf->error_pages, prev->error_pages, NULL);
+ 
+     ngx_conf_merge_str_value(conf->default_type,
+                               prev->default_type, "text/plain");
+@@ -3988,6 +3996,10 @@
+     ngx_http_compile_complex_value_t   ccv;
+ 
+     if (clcf->error_pages == NULL) {
++        return "conflicts with \"no_error_pages\"";
++    }
++
++    if (clcf->error_pages == NGX_CONF_UNSET_PTR) {
+         clcf->error_pages = ngx_array_create(cf->pool, 4,
+                                              sizeof(ngx_http_err_page_t));
+         if (clcf->error_pages == NULL) {
+@@ -4095,6 +4107,25 @@
+ 
+ 
+ static char *
++ngx_http_core_no_error_pages(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
++{
++    ngx_http_core_loc_conf_t *clcf = conf;
++
++    if (clcf->error_pages == NULL) {
++        return "is duplicate";
++    }
++
++    if (clcf->error_pages != NGX_CONF_UNSET_PTR) {
++        return "conflicts with \"error_page\"";
++    }
++
++    clcf->error_pages = NULL;
++
++    return NGX_CONF_OK;
++}
++
++
++static char *
+ ngx_http_core_try_files(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+ {
+     ngx_http_core_loc_conf_t *clcf = conf;

patches/nginx-1.9.11-no_pool.patch

@@ -0,0 +1,585 @@
+diff --minimal '--exclude=*.swp' '--exclude=*~' -up nginx-1.9.11/src/core/nginx.h nginx-1.9.11-patched/src/core/nginx.h
+--- nginx-1.9.11/src/core/nginx.h	2014-07-08 06:22:39.000000000 -0700
++++ nginx-1.9.11-patched/src/core/nginx.h	2014-07-13 19:21:54.117099631 -0700
+@@ -10,7 +10,7 @@
+ 
+ 
+ #define nginx_version      1009011
+ #define NGINX_VERSION      "1.9.11"
+-#define NGINX_VER          "openresty/" NGINX_VERSION ".unknown"
++#define NGINX_VER          "openresty/" NGINX_VERSION ".unknown (no pool)"
+ 
+ #ifdef NGX_BUILD
+diff --minimal '--exclude=*.swp' '--exclude=*~' -up nginx-1.9.11/src/core/ngx_array.c nginx-1.9.11-patched/src/core/ngx_array.c
+--- nginx-1.9.11/src/core/ngx_array.c	2014-07-08 06:22:39.000000000 -0700
++++ nginx-1.9.11-patched/src/core/ngx_array.c	2014-07-13 19:21:54.117099631 -0700
+@@ -30,26 +30,30 @@ ngx_array_create(ngx_pool_t *p, ngx_uint
+ void
+ ngx_array_destroy(ngx_array_t *a)
+ {
+-    ngx_pool_t  *p;
++    ngx_pool_t          *p;
++    ngx_array_link_t    *link;
+ 
+     p = a->pool;
+ 
+-    if ((u_char *) a->elts + a->size * a->nalloc == p->d.last) {
+-        p->d.last -= a->size * a->nalloc;
++    if (a->elts) {
++        ngx_pfree(p, a->elts);
+     }
+ 
+-    if ((u_char *) a + sizeof(ngx_array_t) == p->d.last) {
+-        p->d.last = (u_char *) a;
++    for (link = a->old_elts; link; link = link->next) {
++        ngx_pfree(p, link->elts);
+     }
++
++    ngx_pfree(p, a);
+ }
+ 
+ 
+ void *
+ ngx_array_push(ngx_array_t *a)
+ {
+-    void        *elt, *new;
+-    size_t       size;
+-    ngx_pool_t  *p;
++    void                *elt, *new;
++    size_t               size;
++    ngx_pool_t          *p;
++    ngx_array_link_t    *link;
+ 
+     if (a->nelts == a->nalloc) {
+ 
+@@ -59,29 +63,27 @@ ngx_array_push(ngx_array_t *a)
+ 
+         p = a->pool;
+ 
+-        if ((u_char *) a->elts + size == p->d.last
+-            && p->d.last + a->size <= p->d.end)
+-        {
+-            /*
+-             * the array allocation is the last in the pool
+-             * and there is space for new allocation
+-             */
+-
+-            p->d.last += a->size;
+-            a->nalloc++;
++        /* allocate a new array */
+ 
+-        } else {
+-            /* allocate a new array */
++        new = ngx_palloc(p, 2 * size);
++        if (new == NULL) {
++            return NULL;
++        }
+ 
+-            new = ngx_palloc(p, 2 * size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
++        ngx_memcpy(new, a->elts, size);
+ 
+-            ngx_memcpy(new, a->elts, size);
+-            a->elts = new;
+-            a->nalloc *= 2;
++        link = ngx_palloc(p, sizeof(ngx_array_link_t));
++        if (link == NULL) {
++            ngx_pfree(p, new);
++            return NULL;
+         }
++
++        link->next = a->old_elts;
++        link->elts = a->elts;
++        a->old_elts = link;
++
++        a->elts = new;
++        a->nalloc *= 2;
+     }
+ 
+     elt = (u_char *) a->elts + a->size * a->nelts;
+@@ -95,11 +97,10 @@ void *
+ ngx_array_push_n(ngx_array_t *a, ngx_uint_t n)
+ {
+     void        *elt, *new;
+-    size_t       size;
+     ngx_uint_t   nalloc;
+     ngx_pool_t  *p;
+ 
+-    size = n * a->size;
++    ngx_array_link_t    *link;
+ 
+     if (a->nelts + n > a->nalloc) {
+ 
+@@ -107,31 +108,27 @@ ngx_array_push_n(ngx_array_t *a, ngx_uin
+ 
+         p = a->pool;
+ 
+-        if ((u_char *) a->elts + a->size * a->nalloc == p->d.last
+-            && p->d.last + size <= p->d.end)
+-        {
+-            /*
+-             * the array allocation is the last in the pool
+-             * and there is space for new allocation
+-             */
++        nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
+ 
+-            p->d.last += size;
+-            a->nalloc += n;
++        new = ngx_palloc(p, nalloc * a->size);
++        if (new == NULL) {
++            return NULL;
++        }
+ 
+-        } else {
+-            /* allocate a new array */
++        ngx_memcpy(new, a->elts, a->nelts * a->size);
+ 
+-            nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
++        link = ngx_palloc(p, sizeof(ngx_array_link_t));
++        if (link == NULL) {
++            ngx_pfree(p, new);
++            return NULL;
++        }
+ 
+-            new = ngx_palloc(p, nalloc * a->size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
++        link->next = a->old_elts;
++        link->elts = a->elts;
++        a->old_elts = link;
+ 
+-            ngx_memcpy(new, a->elts, a->nelts * a->size);
+-            a->elts = new;
+-            a->nalloc = nalloc;
+-        }
++        a->elts = new;
++        a->nalloc = nalloc;
+     }
+ 
+     elt = (u_char *) a->elts + a->size * a->nelts;
+diff --minimal '--exclude=*.swp' '--exclude=*~' -up nginx-1.9.11/src/core/ngx_array.h nginx-1.9.11-patched/src/core/ngx_array.h
+--- nginx-1.9.11/src/core/ngx_array.h	2014-07-08 06:22:39.000000000 -0700
++++ nginx-1.9.11-patched/src/core/ngx_array.h	2014-07-13 19:21:54.118099637 -0700
+@@ -13,12 +13,23 @@
+ #include <ngx_core.h>
+ 
+ 
++typedef struct ngx_array_link_s ngx_array_link_t;
++
++
++struct ngx_array_link_s {
++    void                    *elts;
++    ngx_array_link_t        *next;
++};
++
++
+ typedef struct {
+     void        *elts;
+     ngx_uint_t   nelts;
+     size_t       size;
+     ngx_uint_t   nalloc;
+     ngx_pool_t  *pool;
++
++    ngx_array_link_t *old_elts;
+ } ngx_array_t;
+ 
+ 
+@@ -40,6 +51,7 @@ ngx_array_init(ngx_array_t *array, ngx_p
+     array->size = size;
+     array->nalloc = n;
+     array->pool = pool;
++    array->old_elts = NULL;
+ 
+     array->elts = ngx_palloc(pool, n * size);
+     if (array->elts == NULL) {
+diff --minimal '--exclude=*.swp' '--exclude=*~' -up nginx-1.9.11/src/core/ngx_palloc.c nginx-1.9.11-patched/src/core/ngx_palloc.c
+--- nginx-1.9.11/src/core/ngx_palloc.c	2014-07-08 06:22:39.000000000 -0700
++++ nginx-1.9.11-patched/src/core/ngx_palloc.c	2014-07-13 20:04:41.786419098 -0700
+@@ -9,32 +9,26 @@
+ #include <ngx_core.h>
+ 
+ 
+-static void *ngx_palloc_block(ngx_pool_t *pool, size_t size);
+-static void *ngx_palloc_large(ngx_pool_t *pool, size_t size);
++static void * ngx_malloc(ngx_pool_t *pool, size_t size);
+ 
+ 
+ ngx_pool_t *
+ ngx_create_pool(size_t size, ngx_log_t *log)
+ {
+-    ngx_pool_t  *p;
++    ngx_pool_t        *p;
+ 
+-    p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);
++    size = sizeof(ngx_pool_t);
++    p = ngx_alloc(size, log);
+     if (p == NULL) {
+         return NULL;
+     }
+ 
+-    p->d.last = (u_char *) p + sizeof(ngx_pool_t);
+-    p->d.end = (u_char *) p + size;
+-    p->d.next = NULL;
+-    p->d.failed = 0;
++    ngx_memzero(p, size);
+ 
+     size = size - sizeof(ngx_pool_t);
+     p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;
+ 
+     p->current = p;
+-    p->chain = NULL;
+-    p->large = NULL;
+-    p->cleanup = NULL;
+     p->log = log;
+ 
+     return p;
+@@ -44,8 +38,7 @@ ngx_create_pool(size_t size, ngx_log_t *
+ void
+ ngx_destroy_pool(ngx_pool_t *pool)
+ {
+-    ngx_pool_t          *p, *n;
+-    ngx_pool_large_t    *l;
++    ngx_pool_data_t     *d, *n;
+     ngx_pool_cleanup_t  *c;
+ 
+     for (c = pool->cleanup; c; c = c->next) {
+@@ -56,13 +49,9 @@ ngx_destroy_pool(ngx_pool_t *pool)
+         }
+     }
+ 
+-    for (l = pool->large; l; l = l->next) {
+-
+-        ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", l->alloc);
+-
+-        if (l->alloc) {
+-            ngx_free(l->alloc);
+-        }
++    if (pool->d == NULL) {
++        ngx_free(pool);
++        return;
+     }
+ 
+ #if (NGX_DEBUG)
+@@ -72,9 +61,9 @@ ngx_destroy_pool(ngx_pool_t *pool)
+      * so we cannot use this log while free()ing the pool
+      */
+ 
+-    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
++    for (d = pool->d, n = d->next; ; d = n, n = n->next) {
+         ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
+-                       "free: %p, unused: %uz", p, p->d.end - p->d.last);
++                       "free: %p, unused: %d", d, 0);
+ 
+         if (n == NULL) {
+             break;
+@@ -83,170 +72,82 @@ ngx_destroy_pool(ngx_pool_t *pool)
+ 
+ #endif
+ 
+-    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
+-        ngx_free(p);
++    for (d = pool->d, n = d->next; ; d = n, n = n->next) {
++        ngx_free(d->alloc);
++        ngx_free(d);
+ 
+         if (n == NULL) {
+             break;
+         }
+     }
++
++    pool->d = NULL;
++    ngx_free(pool);
+ }
+ 
+ 
+ void
+ ngx_reset_pool(ngx_pool_t *pool)
+ {
+-    ngx_pool_t        *p;
+-    ngx_pool_large_t  *l;
++    ngx_pool_data_t     *d, *n;
++    ngx_pool_data_t     *saved = NULL;
+ 
+-    for (l = pool->large; l; l = l->next) {
+-        if (l->alloc) {
+-            ngx_free(l->alloc);
++    if (pool->d) {
++        for (d = pool->d, n = d->next; ; d = n, n = n->next) {
++            if (d->alloc == pool->log) {
++                saved = d;
++                continue;
++            }
++
++            ngx_free(d->alloc);
++            ngx_free(d);
++
++            if (n == NULL) {
++                break;
++            }
+         }
+-    }
+ 
+-    for (p = pool; p; p = p->d.next) {
+-        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
+-        p->d.failed = 0;
++        pool->d = saved;
++        pool->current = pool;
++        pool->chain = NULL;
+     }
+-
+-    pool->current = pool;
+-    pool->chain = NULL;
+-    pool->large = NULL;
+ }
+ 
+ 
+ void *
+ ngx_palloc(ngx_pool_t *pool, size_t size)
+ {
+-    u_char      *m;
+-    ngx_pool_t  *p;
+-
+-    if (size <= pool->max) {
+-
+-        p = pool->current;
+-
+-        do {
+-            m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);
+-
+-            if ((size_t) (p->d.end - m) >= size) {
+-                p->d.last = m + size;
+-
+-                return m;
+-            }
+-
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
+-    }
+-
+-    return ngx_palloc_large(pool, size);
++    return ngx_malloc(pool, size);
+ }
+ 
+ 
+ void *
+ ngx_pnalloc(ngx_pool_t *pool, size_t size)
+ {
+-    u_char      *m;
+-    ngx_pool_t  *p;
+-
+-    if (size <= pool->max) {
+-
+-        p = pool->current;
+-
+-        do {
+-            m = p->d.last;
+-
+-            if ((size_t) (p->d.end - m) >= size) {
+-                p->d.last = m + size;
+-
+-                return m;
+-            }
+-
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
+-    }
+-
+-    return ngx_palloc_large(pool, size);
+-}
+-
+-
+-static void *
+-ngx_palloc_block(ngx_pool_t *pool, size_t size)
+-{
+-    u_char      *m;
+-    size_t       psize;
+-    ngx_pool_t  *p, *new;
+-
+-    psize = (size_t) (pool->d.end - (u_char *) pool);
+-
+-    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
+-    if (m == NULL) {
+-        return NULL;
+-    }
+-
+-    new = (ngx_pool_t *) m;
+-
+-    new->d.end = m + psize;
+-    new->d.next = NULL;
+-    new->d.failed = 0;
+-
+-    m += sizeof(ngx_pool_data_t);
+-    m = ngx_align_ptr(m, NGX_ALIGNMENT);
+-    new->d.last = m + size;
+-
+-    for (p = pool->current; p->d.next; p = p->d.next) {
+-        if (p->d.failed++ > 4) {
+-            pool->current = p->d.next;
+-        }
+-    }
+-
+-    p->d.next = new;
+-
+-    return m;
++    return ngx_malloc(pool, size);
+ }
+ 
+ 
+ static void *
+-ngx_palloc_large(ngx_pool_t *pool, size_t size)
++ngx_malloc(ngx_pool_t *pool, size_t size)
+ {
+-    void              *p;
+-    ngx_uint_t         n;
+-    ngx_pool_large_t  *large;
++    void                *p;
++    ngx_pool_data_t     *d;
+ 
+     p = ngx_alloc(size, pool->log);
+     if (p == NULL) {
+         return NULL;
+     }
+ 
+-    n = 0;
+-
+-    for (large = pool->large; large; large = large->next) {
+-        if (large->alloc == NULL) {
+-            large->alloc = p;
+-            return p;
+-        }
+-
+-        if (n++ > 3) {
+-            break;
+-        }
+-    }
+-
+-    large = ngx_palloc(pool, sizeof(ngx_pool_large_t));
+-    if (large == NULL) {
++    d = ngx_alloc(sizeof(ngx_pool_data_t), pool->log);
++    if (d == NULL){
+         ngx_free(p);
+         return NULL;
+     }
+ 
+-    large->alloc = p;
+-    large->next = pool->large;
+-    pool->large = large;
+-
++    d->alloc = p;
++    d->next = pool->d;
++    pool->d = d;
+     return p;
+ }
+ 
+@@ -255,38 +156,48 @@ void *
+ ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment)
+ {
+     void              *p;
+-    ngx_pool_large_t  *large;
++    ngx_pool_data_t   *d;
+ 
+     p = ngx_memalign(alignment, size, pool->log);
+     if (p == NULL) {
+         return NULL;
+     }
+ 
+-    large = ngx_palloc(pool, sizeof(ngx_pool_large_t));
+-    if (large == NULL) {
++    d = ngx_alloc(sizeof(ngx_pool_data_t), pool->log);
++    if (d == NULL){
+         ngx_free(p);
+         return NULL;
+     }
+ 
+-    large->alloc = p;
+-    large->next = pool->large;
+-    pool->large = large;
+-
++    d->alloc = p;
++    d->next = pool->d;
++    pool->d = d;
+     return p;
+ }
+ 
+ 
+ ngx_int_t
+-ngx_pfree(ngx_pool_t *pool, void *p)
++ngx_pfree(ngx_pool_t *pool, void *data)
+ {
+-    ngx_pool_large_t  *l;
++    ngx_pool_data_t     *p, *d;
+ 
+-    for (l = pool->large; l; l = l->next) {
+-        if (p == l->alloc) {
+-            ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
+-                           "free: %p", l->alloc);
+-            ngx_free(l->alloc);
+-            l->alloc = NULL;
++    p = NULL;
++    for (d = pool->d; d; p = d, d = d->next) {
++        if (data == d->alloc) {
++
++            ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", d->alloc);
++
++            ngx_free(d->alloc);
++            d->alloc = NULL;
++
++            if (p) {
++                p->next = d->next;
++
++            } else {
++                pool->d = d->next;
++            }
++
++            ngx_free(d);
+ 
+             return NGX_OK;
+         }
+diff --minimal '--exclude=*.swp' '--exclude=*~' -up nginx-1.9.11/src/core/ngx_palloc.h nginx-1.9.11-patched/src/core/ngx_palloc.h
+--- nginx-1.9.11/src/core/ngx_palloc.h	2014-07-08 06:22:39.000000000 -0700
++++ nginx-1.9.11-patched/src/core/ngx_palloc.h	2014-07-13 19:21:54.119099642 -0700
+@@ -38,28 +38,21 @@ struct ngx_pool_cleanup_s {
+ };
+ 
+ 
+-typedef struct ngx_pool_large_s  ngx_pool_large_t;
+-
+-struct ngx_pool_large_s {
+-    ngx_pool_large_t     *next;
+-    void                 *alloc;
+-};
++typedef struct ngx_pool_data_s   ngx_pool_large_t;
++typedef struct ngx_pool_data_s   ngx_pool_data_t;
+ 
+ 
+-typedef struct {
+-    u_char               *last;
+-    u_char               *end;
+-    ngx_pool_t           *next;
+-    ngx_uint_t            failed;
+-} ngx_pool_data_t;
++struct ngx_pool_data_s {
++    ngx_pool_data_t        *next;
++    void                   *alloc;
++};
+ 
+ 
+ struct ngx_pool_s {
+-    ngx_pool_data_t       d;
++    ngx_pool_data_t      *d;
+     size_t                max;
+     ngx_pool_t           *current;
+     ngx_chain_t          *chain;
+-    ngx_pool_large_t     *large;
+     ngx_pool_cleanup_t   *cleanup;
+     ngx_log_t            *log;
+ };

patches/nginx-1.9.11-pcre_conf_opt.patch

@@ -0,0 +1,26 @@
+# HG changeset patch
+# User Yichun Zhang <agentzh@gmail.com>
+# Date 1386694955 28800
+# Node ID 9ba6b149669f1f02eeb4cdc0ebd364a949b5c469
+# Parent  30e806b8636af5fd3f03ec17df24801f390f7511
+Configure: added new option --with-pcre-conf-opt=OPTIONS.
+
+diff -r 30e806b8636a -r 9ba6b149669f auto/options
+--- a/auto/options	Mon Dec 09 10:16:44 2013 +0400
++++ b/auto/options	Tue Dec 10 09:02:35 2013 -0800
+@@ -286,6 +286,7 @@
+         --with-pcre)                     USE_PCRE=YES               ;;
+         --with-pcre=*)                   PCRE="$value"              ;;
+         --with-pcre-opt=*)               PCRE_OPT="$value"          ;;
++        --with-pcre-conf-opt=*)          PCRE_CONF_OPT="$value"     ;;
+         --with-pcre-jit)                 PCRE_JIT=YES               ;;
+ 
+         --with-openssl=*)                OPENSSL="$value"           ;;
+@@ -441,6 +442,7 @@
+   --with-pcre                        force PCRE library usage
+   --with-pcre=DIR                    set path to PCRE library sources
+   --with-pcre-opt=OPTIONS            set additional build options for PCRE
++  --with-pcre-conf-opt=OPTIONS       set additional configure options for PCRE
+   --with-pcre-jit                    build PCRE with JIT compilation support
+ 
+   --with-md5=DIR                     set path to md5 library sources

patches/nginx-1.9.11-proxy_host_port_vars.patch

@@ -0,0 +1,15 @@
+--- nginx-1.9.11/src/http/modules/ngx_http_proxy_module.c	2013-10-08 05:07:14.000000000 -0700
++++ nginx-1.9.11-patched/src/http/modules/ngx_http_proxy_module.c	2013-10-27 15:29:41.619378592 -0700
+@@ -602,10 +602,10 @@ static ngx_keyval_t  ngx_http_proxy_cach
+ static ngx_http_variable_t  ngx_http_proxy_vars[] = {
+ 
+     { ngx_string("proxy_host"), NULL, ngx_http_proxy_host_variable, 0,
+-      NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },
++      NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE, 0 },
+ 
+     { ngx_string("proxy_port"), NULL, ngx_http_proxy_port_variable, 0,
+-      NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE|NGX_HTTP_VAR_NOHASH, 0 },
++      NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE, 0 },
+ 
+     { ngx_string("proxy_add_x_forwarded_for"), NULL,
+       ngx_http_proxy_add_x_forwarded_for_variable, 0, NGX_HTTP_VAR_NOHASH, 0 },

patches/nginx-1.9.11-server_header.patch

@@ -0,0 +1,24 @@
+diff -ur nginx-1.9.11/src/core/nginx.h nginx-1.9.11-patched/src/core/nginx.h
+--- nginx-1.9.11/src/core/nginx.h	2010-02-12 17:31:01.000000000 +0800
++++ nginx-1.9.11-patched/src/core/nginx.h	2010-03-30 10:52:13.240702627 +0800
+@@ -10,7 +10,7 @@
+ 
+ #define nginx_version         1009011
+ #define NGINX_VERSION      "1.9.11"
+-#define NGINX_VER          "nginx/" NGINX_VERSION
++#define NGINX_VER          "openresty/" NGINX_VERSION ".unknown"
+ 
+ #define NGINX_VAR          "NGINX"
+ #define NGX_OLDPID_EXT     ".oldbin"
+diff -ur nginx-1.9.11/src/http/ngx_http_header_filter_module.c nginx-1.9.11-patched/src/http/ngx_http_header_filter_module.c
+--- nginx-1.9.11/src/http/ngx_http_header_filter_module.c	2010-03-03 23:14:04.000000000 +0800
++++ nginx-1.9.11-patched/src/http/ngx_http_header_filter_module.c	2010-03-30 10:52:53.670909405 +0800
+@@ -45,7 +45,7 @@
+ };
+ 
+ 
+-static char ngx_http_server_string[] = "Server: nginx" CRLF;
++static char ngx_http_server_string[] = "Server: openresty" CRLF;
+ static char ngx_http_server_full_string[] = "Server: " NGINX_VER CRLF;
+ 
+ 

patches/nginx-1.9.11-setting_args_invalidates_uri.patch

@@ -0,0 +1,44 @@
+# HG changeset patch
+# User Yichun Zhang <agentzh@gmail.com>
+# Date 1390506359 28800
+# Node ID 17186b98c235c07e94c64e5853689f790f173756
+# Parent  4b50d1f299d8a69f3e3f7975132e1490352642fe
+Variable: setting $args should invalidate unparsed uri.
+
+diff -r 4b50d1f299d8 -r 17186b98c235 src/http/ngx_http_variables.c
+--- a/src/http/ngx_http_variables.c	Fri Jan 10 11:22:14 2014 -0800
++++ b/src/http/ngx_http_variables.c	Thu Jan 23 11:45:59 2014 -0800
+@@ -15,6 +15,8 @@
+     ngx_http_variable_value_t *v, uintptr_t data);
+ static void ngx_http_variable_request_set(ngx_http_request_t *r,
+     ngx_http_variable_value_t *v, uintptr_t data);
++static void ngx_http_variable_request_args_set(ngx_http_request_t *r,
++    ngx_http_variable_value_t *v, uintptr_t data);
+ static ngx_int_t ngx_http_variable_request_get_size(ngx_http_request_t *r,
+     ngx_http_variable_value_t *v, uintptr_t data);
+ static void ngx_http_variable_request_set_size(ngx_http_request_t *r,
+@@ -218,7 +220,7 @@
+       NGX_HTTP_VAR_NOCACHEABLE, 0 },
+ 
+     { ngx_string("args"),
+-      ngx_http_variable_request_set,
++      ngx_http_variable_request_args_set,
+       ngx_http_variable_request,
+       offsetof(ngx_http_request_t, args),
+       NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOCACHEABLE, 0 },
+@@ -647,6 +649,15 @@
+ 
+ 
+ static void
++ngx_http_variable_request_args_set(ngx_http_request_t *r,
++    ngx_http_variable_value_t *v, uintptr_t data)
++{
++    r->valid_unparsed_uri = 0;
++    ngx_http_variable_request_set(r, v, data);
++}
++
++
++static void
+ ngx_http_variable_request_set(ngx_http_request_t *r,
+     ngx_http_variable_value_t *v, uintptr_t data)
+ {

patches/nginx-1.9.11-slab_defrag.patch

@@ -0,0 +1,138 @@
+diff --git a/src/core/ngx_slab.c b/src/core/ngx_slab.c
+index c3a27f7..1bde432 100644
+--- a/src/core/ngx_slab.c
++++ b/src/core/ngx_slab.c
+@@ -6,6 +6,7 @@
+ 
+ #include <ngx_config.h>
+ #include <ngx_core.h>
++#include <assert.h>
+ 
+ 
+ #define NGX_SLAB_PAGE_MASK   3
+@@ -111,6 +112,7 @@ ngx_slab_init(ngx_slab_pool_t *pool)
+     ngx_memzero(p, pages * sizeof(ngx_slab_page_t));
+ 
+     pool->pages = (ngx_slab_page_t *) p;
++    pool->npages = pages;
+ 
+     pool->free.prev = 0;
+     pool->free.next = (ngx_slab_page_t *) p;
+@@ -118,6 +120,7 @@ ngx_slab_init(ngx_slab_pool_t *pool)
+     pool->pages->slab = pages;
+     pool->pages->next = &pool->free;
+     pool->pages->prev = (uintptr_t) &pool->free;
++    pool->pages->prev_slab = 0;
+ 
+     pool->start = (u_char *)
+                   ngx_align_ptr((uintptr_t) p + pages * sizeof(ngx_slab_page_t),
+@@ -625,9 +628,16 @@ ngx_slab_alloc_pages(ngx_slab_pool_t *pool, ngx_uint_t pages)
+         if (page->slab >= pages) {
+ 
+             if (page->slab > pages) {
++                /* adjust the next adjacent block's "prev_slab" field */
++                p = &page[page->slab];
++                if (p < pool->pages + pool->npages) {
++                    p->prev_slab = page->slab - pages;
++                }
++
+                 page[pages].slab = page->slab - pages;
+                 page[pages].next = page->next;
+                 page[pages].prev = page->prev;
++                page[pages].prev_slab = pages;
+ 
+                 p = (ngx_slab_page_t *) page->prev;
+                 p->next = &page[pages];
+@@ -651,6 +661,7 @@ ngx_slab_alloc_pages(ngx_slab_pool_t *pool, ngx_uint_t pages)
+                 p->slab = NGX_SLAB_PAGE_BUSY;
+                 p->next = NULL;
+                 p->prev = NGX_SLAB_PAGE;
++                p->prev_slab = 0;
+                 p++;
+             }
+ 
+@@ -668,7 +679,7 @@ static void
+ ngx_slab_free_pages(ngx_slab_pool_t *pool, ngx_slab_page_t *page,
+     ngx_uint_t pages)
+ {
+-    ngx_slab_page_t  *prev;
++    ngx_slab_page_t  *prev, *p;
+ 
+     page->slab = pages--;
+ 
+@@ -682,6 +693,53 @@ ngx_slab_free_pages(ngx_slab_pool_t *pool, ngx_slab_page_t *page,
+         page->next->prev = page->prev;
+     }
+ 
++    /* merge the next adjacent free block if it is free */
++
++    p = &page[page->slab];
++    if (p < pool->pages + pool->npages
++        && !(p->slab & NGX_SLAB_PAGE_START)
++        && p->next != NULL
++        && (p->prev & NGX_SLAB_PAGE_MASK) == NGX_SLAB_PAGE)
++    {
++        page->slab += p->slab;
++
++        /* remove the next adjacent block from the free list */
++
++        prev = (ngx_slab_page_t *) p->prev;
++        prev->next = p->next;
++        p->next->prev = p->prev;
++
++        /* adjust the "prev_slab" field in the next next adjacent block */
++        if (p + p->slab < pool->pages + pool->npages) {
++            p[p->slab].prev_slab = page->slab;
++        }
++
++        ngx_memzero(p, sizeof(ngx_slab_page_t));
++    }
++
++    if (page->prev_slab) {
++        /* merge the previous adjacent block if it is free */
++
++        p = page - page->prev_slab;
++        if (!(p->slab & NGX_SLAB_PAGE_START)
++            && p->next != NULL
++            && (p->prev & NGX_SLAB_PAGE_MASK) == NGX_SLAB_PAGE)
++        {
++            assert(p->slab == page->prev_slab);
++
++            p->slab += page->slab;
++            ngx_memzero(page, sizeof(ngx_slab_page_t));
++
++            /* adjust the "prev_slab" field in the next adjacent block */
++            if (p + p->slab < pool->pages + pool->npages) {
++                p[p->slab].prev_slab = p->slab;
++            }
++
++            /* skip adding "page" to the free list */
++            return;
++        }
++    }
++
+     page->prev = (uintptr_t) &pool->free;
+     page->next = pool->free.next;
+ 
+diff --git a/src/core/ngx_slab.h b/src/core/ngx_slab.h
+index c5e420b..287ac79 100644
+--- a/src/core/ngx_slab.h
++++ b/src/core/ngx_slab.h
+@@ -19,6 +19,8 @@ struct ngx_slab_page_s {
+     uintptr_t         slab;
+     ngx_slab_page_t  *next;
+     uintptr_t         prev;
++    uintptr_t         prev_slab;
++                         /* number of pages for the previous adjacent block */
+ };
+ 
+ 
+@@ -31,6 +33,8 @@ typedef struct {
+     ngx_slab_page_t  *pages;
+     ngx_slab_page_t   free;
+ 
++    ngx_uint_t        npages;
++
+     u_char           *start;
+     u_char           *end;
+ 

patches/nginx-1.9.11-ssl_cert_cb_yield.patch

@@ -0,0 +1,42 @@
+# HG changeset patch
+# User Yichun Zhang <agentzh@openresty.org>
+# Date 1451762084 28800
+#      Sat Jan 02 11:14:44 2016 -0800
+# Node ID 449f0461859c16e95bdb18e8be6b94401545d3dd
+# Parent  78b4e10b4367b31367aad3c83c9c3acdd42397c4
+SSL: handled SSL_CTX_set_cert_cb() callback yielding.
+
+OpenSSL 1.0.2+ introduces SSL_CTX_set_cert_cb() to allow custom
+callbacks to serve the SSL certificiates and private keys dynamically
+and lazily. The callbacks may yield for nonblocking I/O or sleeping.
+Here we added support for such usage in NGINX 3rd-party modules
+(like ngx_lua) in NGINX's event handlers for downstream SSL
+connections.
+
+diff -r 78b4e10b4367 -r 449f0461859c src/event/ngx_event_openssl.c
+--- a/src/event/ngx_event_openssl.c	Thu Dec 17 16:39:15 2015 +0300
++++ b/src/event/ngx_event_openssl.c	Sat Jan 02 11:14:44 2016 -0800
+@@ -1210,6 +1210,23 @@
+         return NGX_AGAIN;
+     }
+ 
++#if OPENSSL_VERSION_NUMBER >= 0x10002000L
++    if (sslerr == SSL_ERROR_WANT_X509_LOOKUP) {
++        c->read->handler = ngx_ssl_handshake_handler;
++        c->write->handler = ngx_ssl_handshake_handler;
++
++        if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
++            return NGX_ERROR;
++        }
++
++        if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
++            return NGX_ERROR;
++        }
++
++        return NGX_AGAIN;
++    }
++#endif
++
+     err = (sslerr == SSL_ERROR_SYSCALL) ? ngx_errno : 0;
+ 
+     c->ssl->no_wait_shutdown = 1;

patches/nginx-1.9.11-upstream_pipelining.patch

@@ -0,0 +1,23 @@
+commit f9907b72a76a21ac5413187b83177a919475c75f
+Author: Yichun Zhang (agentzh) <agentzh@gmail.com>
+Date:   Wed Feb 10 16:05:08 2016 -0800
+
+    bugfix: upstream: keep sending request data after the first write attempt.
+    
+    See
+    http://mailman.nginx.org/pipermail/nginx-devel/2012-March/002040.html
+    for more details on the issue.
+
+diff --git a/src/http/ngx_http_upstream.c b/src/http/ngx_http_upstream.c
+index dbaa956..a25aaa2 100644
+--- a/src/http/ngx_http_upstream.c
++++ b/src/http/ngx_http_upstream.c
+@@ -2003,7 +2003,7 @@ ngx_http_upstream_send_request_handler(ngx_http_request_t *r,
+ 
+ #endif
+ 
+-    if (u->header_sent) {
++    if (u->request_body_sent) {
+         u->write_event_handler = ngx_http_upstream_dummy_handler;
+ 
+         (void) ngx_handle_write_event(c->write, 0);

patches/nginx-1.9.7-dtrace.patch

@@ -451,21 +451,6 @@ index ef4a647..49bb30b 100644
      return p;
  }
  
-diff --git a/src/core/ngx_thread_pool.h b/src/core/ngx_thread_pool.h
-index 5e5adf6..5999525 100644
---- a/src/core/ngx_thread_pool.h
-+++ b/src/core/ngx_thread_pool.h
-@@ -23,7 +23,10 @@ struct ngx_thread_task_s {
- };
- 
- 
-+#ifndef NGX_DEFINE_THREAD_POOL_T
-+#define NGX_DEFINE_THREAD_POOL_T 1
- typedef struct ngx_thread_pool_s  ngx_thread_pool_t;
-+#endif
- 
- 
- ngx_thread_pool_t *ngx_thread_pool_add(ngx_conf_t *cf, ngx_str_t *name);
 diff --git a/src/dtrace/nginx.stp b/src/dtrace/nginx.stp
 new file mode 100644
 index 0000000..e824daf
@@ -831,10 +816,10 @@ index 0000000..1bca4cf
 +
 diff --git a/src/event/ngx_event_probe.h b/src/event/ngx_event_probe.h
 new file mode 100644
-index 0000000..9fa2a82
+index 0000000..5aa0397
 --- /dev/null
 +++ b/src/event/ngx_event_probe.h
-@@ -0,0 +1,40 @@
+@@ -0,0 +1,33 @@
 +#ifndef _NGX_EVENT_PROBE_H_INCLUDED_
 +#define _NGX_EVENT_PROBE_H_INCLUDED_
 +
@@ -846,13 +831,6 @@ index 0000000..9fa2a82
 +
 +#if (NGX_DTRACE)
 +
-+#if (NGX_THREADS)
-+#   ifndef NGX_DEFINE_THREAD_POOL_T
-+#   define NGX_DEFINE_THREAD_POOL_T 1
-+typedef struct ngx_thread_pool_s  ngx_thread_pool_t;
-+#   endif
-+#endif
-+
 +#include <ngx_http.h>
 +#include <ngx_dtrace_provider.h>
 +
@@ -876,10 +854,18 @@ index 0000000..9fa2a82
 +
 +#endif /* _NGX_EVENT_PROBE_H_INCLUDED_ */
 diff --git a/src/event/ngx_event_timer.c b/src/event/ngx_event_timer.c
-index 8f547b2..e12a51e 100644
+index 8f547b2..6e77465 100644
 --- a/src/event/ngx_event_timer.c
 +++ b/src/event/ngx_event_timer.c
-@@ -91,6 +91,8 @@ ngx_event_expire_timers(void)
+@@ -8,6 +8,7 @@
+ #include <ngx_config.h>
+ #include <ngx_core.h>
+ #include <ngx_event.h>
++#include <ngx_event_probe.h>
+ 
+ 
+ ngx_rbtree_t              ngx_event_timer_rbtree;
+@@ -91,6 +92,8 @@ ngx_event_expire_timers(void)
  
          ev->timedout = 1;
  
@@ -888,32 +874,61 @@ index 8f547b2..e12a51e 100644
          ev->handler(ev);
      }
  }
+@@ -136,3 +139,19 @@ ngx_event_cancel_timers(void)
+         ev->handler(ev);
+     }
+ }
++
++
++#if (NGX_DTRACE)
++void
++ngx_event_probe_timer_add_helper(ngx_event_t *ev, ngx_msec_t timer)
++{
++    ngx_event_probe_timer_add(ev, timer);
++}
++
++
++void
++ngx_event_probe_timer_del_helper(ngx_event_t *ev)
++{
++    ngx_event_probe_timer_del(ev);
++}
++#endif
 diff --git a/src/event/ngx_event_timer.h b/src/event/ngx_event_timer.h
-index 99f8a48..79c3fa0 100644
+index 99f8a48..8bc619a 100644
 --- a/src/event/ngx_event_timer.h
 +++ b/src/event/ngx_event_timer.h
-@@ -12,6 +12,7 @@
- #include <ngx_config.h>
- #include <ngx_core.h>
- #include <ngx_event.h>
-+#include <ngx_event_probe.h>
+@@ -25,12 +25,23 @@ void ngx_event_expire_timers(void);
+ void ngx_event_cancel_timers(void);
+ 
+ 
++#if (NGX_DTRACE)
++void ngx_event_probe_timer_add_helper(ngx_event_t *ev,
++    ngx_msec_t timer);
++void ngx_event_probe_timer_del_helper(ngx_event_t *ev);
++#endif
++
++
+ extern ngx_rbtree_t  ngx_event_timer_rbtree;
  
  
- #define NGX_TIMER_INFINITE  (ngx_msec_t) -1
-@@ -31,6 +32,8 @@ extern ngx_rbtree_t  ngx_event_timer_rbtree;
  static ngx_inline void
  ngx_event_del_timer(ngx_event_t *ev)
  {
-+    ngx_event_probe_timer_del(ev);
++#if (NGX_DTRACE)
++    ngx_event_probe_timer_del_helper(ev);
++#endif
 +
      ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
                     "event timer del: %d: %M",
                      ngx_event_ident(ev->data), ev->timer.key);
-@@ -77,6 +80,8 @@ ngx_event_add_timer(ngx_event_t *ev, ngx_msec_t timer)
+@@ -77,6 +88,10 @@ ngx_event_add_timer(ngx_event_t *ev, ngx_msec_t timer)
  
      ev->timer.key = key;
  
-+    ngx_event_probe_timer_add(ev, timer);
++#if (NGX_DTRACE)
++    ngx_event_probe_timer_add_helper(ev, timer);
++#endif
 +
      ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
                     "event timer add: %d: %M:%M",

patches/nginx-1.9.7-resolver_security_fixes.patch

@@ -0,0 +1,565 @@
+diff -upr nginx-1.9.7-old/src/core/ngx_resolver.c nginx-1.9.7/src/core/ngx_resolver.c
+--- nginx-1.9.7-old/src/core/ngx_resolver.c	2016-01-26 11:54:55.915406799 -0800
++++ nginx-1.9.7/src/core/ngx_resolver.c	2016-01-26 11:55:27.067782268 -0800
+@@ -59,15 +59,15 @@ ngx_int_t ngx_udp_connect(ngx_udp_connec
+ static void ngx_resolver_cleanup(void *data);
+ static void ngx_resolver_cleanup_tree(ngx_resolver_t *r, ngx_rbtree_t *tree);
+ static ngx_int_t ngx_resolve_name_locked(ngx_resolver_t *r,
+-    ngx_resolver_ctx_t *ctx);
++    ngx_resolver_ctx_t *ctx, ngx_str_t *name);
+ static void ngx_resolver_expire(ngx_resolver_t *r, ngx_rbtree_t *tree,
+     ngx_queue_t *queue);
+ static ngx_int_t ngx_resolver_send_query(ngx_resolver_t *r,
+     ngx_resolver_node_t *rn);
+-static ngx_int_t ngx_resolver_create_name_query(ngx_resolver_node_t *rn,
+-    ngx_resolver_ctx_t *ctx);
+-static ngx_int_t ngx_resolver_create_addr_query(ngx_resolver_node_t *rn,
+-    ngx_resolver_ctx_t *ctx);
++static ngx_int_t ngx_resolver_create_name_query(ngx_resolver_t *r,
++    ngx_resolver_node_t *rn, ngx_str_t *name);
++static ngx_int_t ngx_resolver_create_addr_query(ngx_resolver_t *r,
++    ngx_resolver_node_t *rn, ngx_addr_t *addr);
+ static void ngx_resolver_resend_handler(ngx_event_t *ev);
+ static time_t ngx_resolver_resend(ngx_resolver_t *r, ngx_rbtree_t *tree,
+     ngx_queue_t *queue);
+@@ -376,7 +376,7 @@ ngx_resolve_name(ngx_resolver_ctx_t *ctx
+ 
+     /* lock name mutex */
+ 
+-    rc = ngx_resolve_name_locked(r, ctx);
++    rc = ngx_resolve_name_locked(r, ctx, &ctx->name);
+ 
+     if (rc == NGX_OK) {
+         return NGX_OK;
+@@ -403,7 +403,6 @@ ngx_resolve_name(ngx_resolver_ctx_t *ctx
+ void
+ ngx_resolve_name_done(ngx_resolver_ctx_t *ctx)
+ {
+-    uint32_t              hash;
+     ngx_resolver_t       *r;
+     ngx_resolver_ctx_t   *w, **p;
+     ngx_resolver_node_t  *rn;
+@@ -423,11 +422,9 @@ ngx_resolve_name_done(ngx_resolver_ctx_t
+ 
+     /* lock name mutex */
+ 
+-    if (ctx->state == NGX_AGAIN) {
+-
+-        hash = ngx_crc32_short(ctx->name.data, ctx->name.len);
++    if (ctx->state == NGX_AGAIN || ctx->state == NGX_RESOLVE_TIMEDOUT) {
+ 
+-        rn = ngx_resolver_lookup_name(r, &ctx->name, hash);
++        rn = ctx->node;
+ 
+         if (rn) {
+             p = &rn->waiting;
+@@ -472,23 +469,28 @@ done:
+ 
+ 
+ static ngx_int_t
+-ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx)
++ngx_resolve_name_locked(ngx_resolver_t *r, ngx_resolver_ctx_t *ctx,
++    ngx_str_t *name)
+ {
+     uint32_t              hash;
+     ngx_int_t             rc;
++    ngx_str_t             cname;
+     ngx_uint_t            naddrs;
+     ngx_addr_t           *addrs;
+-    ngx_resolver_ctx_t   *next;
++    ngx_resolver_ctx_t   *next, *last;
+     ngx_resolver_node_t  *rn;
+ 
+-    ngx_strlow(ctx->name.data, ctx->name.data, ctx->name.len);
++    ngx_strlow(name->data, name->data, name->len);
+ 
+-    hash = ngx_crc32_short(ctx->name.data, ctx->name.len);
++    hash = ngx_crc32_short(name->data, name->len);
+ 
+-    rn = ngx_resolver_lookup_name(r, &ctx->name, hash);
++    rn = ngx_resolver_lookup_name(r, name, hash);
+ 
+     if (rn) {
+ 
++        /* ctx can be a list after NGX_RESOLVE_CNAME */
++        for (last = ctx; last->next; last = last->next);
++
+         if (rn->valid >= ngx_time()) {
+ 
+             ngx_log_debug0(NGX_LOG_DEBUG_CORE, r->log, 0, "resolve cached");
+@@ -516,7 +518,7 @@ ngx_resolve_name_locked(ngx_resolver_t *
+                     }
+                 }
+ 
+-                ctx->next = rn->waiting;
++                last->next = rn->waiting;
+                 rn->waiting = NULL;
+ 
+                 /* unlock name mutex */
+@@ -556,13 +558,13 @@ ngx_resolve_name_locked(ngx_resolver_t *
+ 
+             if (ctx->recursion++ < NGX_RESOLVER_MAX_RECURSION) {
+ 
+-                ctx->name.len = rn->cnlen;
+-                ctx->name.data = rn->u.cname;
++                cname.len = rn->cnlen;
++                cname.data = rn->u.cname;
+ 
+-                return ngx_resolve_name_locked(r, ctx);
++                return ngx_resolve_name_locked(r, ctx, &cname);
+             }
+ 
+-            ctx->next = rn->waiting;
++            last->next = rn->waiting;
+             rn->waiting = NULL;
+ 
+             /* unlock name mutex */
+@@ -581,10 +583,29 @@ ngx_resolve_name_locked(ngx_resolver_t *
+ 
+         if (rn->waiting) {
+ 
+-            ctx->next = rn->waiting;
++            if (ctx->event == NULL) {
++                ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
++                if (ctx->event == NULL) {
++                    return NGX_ERROR;
++                }
++
++                ctx->event->handler = ngx_resolver_timeout_handler;
++                ctx->event->data = ctx;
++                ctx->event->log = r->log;
++                ctx->ident = -1;
++
++                ngx_add_timer(ctx->event, ctx->timeout);
++            }
++
++            last->next = rn->waiting;
+             rn->waiting = ctx;
+             ctx->state = NGX_AGAIN;
+ 
++            do {
++                ctx->node = rn;
++                ctx = ctx->next;
++            } while (ctx);
++
+             return NGX_AGAIN;
+         }
+ 
+@@ -623,14 +644,14 @@ ngx_resolve_name_locked(ngx_resolver_t *
+             return NGX_ERROR;
+         }
+ 
+-        rn->name = ngx_resolver_dup(r, ctx->name.data, ctx->name.len);
++        rn->name = ngx_resolver_dup(r, name->data, name->len);
+         if (rn->name == NULL) {
+             ngx_resolver_free(r, rn);
+             return NGX_ERROR;
+         }
+ 
+         rn->node.key = hash;
+-        rn->nlen = (u_short) ctx->name.len;
++        rn->nlen = (u_short) name->len;
+         rn->query = NULL;
+ #if (NGX_HAVE_INET6)
+         rn->query6 = NULL;
+@@ -639,7 +660,7 @@ ngx_resolve_name_locked(ngx_resolver_t *
+         ngx_rbtree_insert(&r->name_rbtree, &rn->node);
+     }
+ 
+-    rc = ngx_resolver_create_name_query(rn, ctx);
++    rc = ngx_resolver_create_name_query(r, rn, name);
+ 
+     if (rc == NGX_ERROR) {
+         goto failed;
+@@ -652,8 +673,14 @@ ngx_resolve_name_locked(ngx_resolver_t *
+         ngx_resolver_free(r, rn->name);
+         ngx_resolver_free(r, rn);
+ 
+-        ctx->state = NGX_RESOLVE_NXDOMAIN;
+-        ctx->handler(ctx);
++        do {
++            ctx->state = NGX_RESOLVE_NXDOMAIN;
++            next = ctx->next;
++
++            ctx->handler(ctx);
++
++            ctx = next;
++        } while (ctx);
+ 
+         return NGX_OK;
+     }
+@@ -674,9 +701,9 @@ ngx_resolve_name_locked(ngx_resolver_t *
+         }
+ 
+         ctx->event->handler = ngx_resolver_timeout_handler;
+-        ctx->event->data = rn;
++        ctx->event->data = ctx;
+         ctx->event->log = r->log;
+-        rn->ident = -1;
++        ctx->ident = -1;
+ 
+         ngx_add_timer(ctx->event, ctx->timeout);
+     }
+@@ -697,6 +724,11 @@ ngx_resolve_name_locked(ngx_resolver_t *
+ 
+     ctx->state = NGX_AGAIN;
+ 
++    do {
++        ctx->node = rn;
++        ctx = ctx->next;
++    } while (ctx);
++
+     return NGX_AGAIN;
+ 
+ failed:
+@@ -804,9 +836,22 @@ ngx_resolve_addr(ngx_resolver_ctx_t *ctx
+ 
+         if (rn->waiting) {
+ 
++            ctx->event = ngx_resolver_calloc(r, sizeof(ngx_event_t));
++            if (ctx->event == NULL) {
++                return NGX_ERROR;
++            }
++
++            ctx->event->handler = ngx_resolver_timeout_handler;
++            ctx->event->data = ctx;
++            ctx->event->log = r->log;
++            ctx->ident = -1;
++
++            ngx_add_timer(ctx->event, ctx->timeout);
++
+             ctx->next = rn->waiting;
+             rn->waiting = ctx;
+             ctx->state = NGX_AGAIN;
++            ctx->node = rn;
+ 
+             /* unlock addr mutex */
+ 
+@@ -848,7 +893,7 @@ ngx_resolve_addr(ngx_resolver_ctx_t *ctx
+         ngx_rbtree_insert(tree, &rn->node);
+     }
+ 
+-    if (ngx_resolver_create_addr_query(rn, ctx) != NGX_OK) {
++    if (ngx_resolver_create_addr_query(r, rn, &ctx->addr) != NGX_OK) {
+         goto failed;
+     }
+ 
+@@ -867,9 +912,9 @@ ngx_resolve_addr(ngx_resolver_ctx_t *ctx
+     }
+ 
+     ctx->event->handler = ngx_resolver_timeout_handler;
+-    ctx->event->data = rn;
++    ctx->event->data = ctx;
+     ctx->event->log = r->log;
+-    rn->ident = -1;
++    ctx->ident = -1;
+ 
+     ngx_add_timer(ctx->event, ctx->timeout);
+ 
+@@ -892,6 +937,7 @@ ngx_resolve_addr(ngx_resolver_ctx_t *ctx
+     /* unlock addr mutex */
+ 
+     ctx->state = NGX_AGAIN;
++    ctx->node = rn;
+ 
+     return NGX_OK;
+ 
+@@ -922,17 +968,11 @@ failed:
+ void
+ ngx_resolve_addr_done(ngx_resolver_ctx_t *ctx)
+ {
+-    in_addr_t             addr;
+     ngx_queue_t          *expire_queue;
+     ngx_rbtree_t         *tree;
+     ngx_resolver_t       *r;
+     ngx_resolver_ctx_t   *w, **p;
+-    struct sockaddr_in   *sin;
+     ngx_resolver_node_t  *rn;
+-#if (NGX_HAVE_INET6)
+-    uint32_t              hash;
+-    struct sockaddr_in6  *sin6;
+-#endif
+ 
+     r = ctx->resolver;
+ 
+@@ -959,23 +999,9 @@ ngx_resolve_addr_done(ngx_resolver_ctx_t
+ 
+     /* lock addr mutex */
+ 
+-    if (ctx->state == NGX_AGAIN) {
+-
+-        switch (ctx->addr.sockaddr->sa_family) {
+-
+-#if (NGX_HAVE_INET6)
+-        case AF_INET6:
+-            sin6 = (struct sockaddr_in6 *) ctx->addr.sockaddr;
+-            hash = ngx_crc32_short(sin6->sin6_addr.s6_addr, 16);
+-            rn = ngx_resolver_lookup_addr6(r, &sin6->sin6_addr, hash);
+-            break;
+-#endif
++    if (ctx->state == NGX_AGAIN || ctx->state == NGX_RESOLVE_TIMEDOUT) {
+ 
+-        default: /* AF_INET */
+-            sin = (struct sockaddr_in *) ctx->addr.sockaddr;
+-            addr = ntohl(sin->sin_addr.s_addr);
+-            rn = ngx_resolver_lookup_addr(r, addr);
+-        }
++        rn = ctx->node;
+ 
+         if (rn) {
+             p = &rn->waiting;
+@@ -1312,7 +1338,7 @@ ngx_resolver_process_response(ngx_resolv
+         times = 0;
+ 
+         for (q = ngx_queue_head(&r->name_resend_queue);
+-             q != ngx_queue_sentinel(&r->name_resend_queue) || times++ < 100;
++             q != ngx_queue_sentinel(&r->name_resend_queue) && times++ < 100;
+              q = ngx_queue_next(q))
+         {
+             rn = ngx_queue_data(q, ngx_resolver_node_t, queue);
+@@ -1975,20 +2001,39 @@ ngx_resolver_process_a(ngx_resolver_t *r
+ 
+         ngx_queue_insert_head(&r->name_expire_queue, &rn->queue);
+ 
++        ngx_resolver_free(r, rn->query);
++        rn->query = NULL;
++#if (NGX_HAVE_INET6)
++        rn->query6 = NULL;
++#endif
++
+         ctx = rn->waiting;
+         rn->waiting = NULL;
+ 
+         if (ctx) {
+-            ctx->name = name;
+ 
+-            (void) ngx_resolve_name_locked(r, ctx);
+-        }
++            if (ctx->recursion++ >= NGX_RESOLVER_MAX_RECURSION) {
+ 
+-        ngx_resolver_free(r, rn->query);
+-        rn->query = NULL;
+-#if (NGX_HAVE_INET6)
+-        rn->query6 = NULL;
+-#endif
++                /* unlock name mutex */
++
++                do {
++                    ctx->state = NGX_RESOLVE_NXDOMAIN;
++                    next = ctx->next;
++
++                    ctx->handler(ctx);
++
++                    ctx = next;
++                } while (ctx);
++
++                return;
++            }
++
++            for (next = ctx; next; next = next->next) {
++                next->node = NULL;
++            }
++
++            (void) ngx_resolve_name_locked(r, ctx, &name);
++        }
+ 
+         /* unlock name mutex */
+ 
+@@ -2496,27 +2541,23 @@ ngx_resolver_rbtree_insert_addr6_value(n
+ 
+ 
+ static ngx_int_t
+-ngx_resolver_create_name_query(ngx_resolver_node_t *rn, ngx_resolver_ctx_t *ctx)
++ngx_resolver_create_name_query(ngx_resolver_t *r, ngx_resolver_node_t *rn,
++    ngx_str_t *name)
+ {
+     u_char              *p, *s;
+     size_t               len, nlen;
+     ngx_uint_t           ident;
+-#if (NGX_HAVE_INET6)
+-    ngx_resolver_t      *r;
+-#endif
+     ngx_resolver_qs_t   *qs;
+     ngx_resolver_hdr_t  *query;
+ 
+-    nlen = ctx->name.len ? (1 + ctx->name.len + 1) : 1;
++    nlen = name->len ? (1 + name->len + 1) : 1;
+ 
+     len = sizeof(ngx_resolver_hdr_t) + nlen + sizeof(ngx_resolver_qs_t);
+ 
+ #if (NGX_HAVE_INET6)
+-    r = ctx->resolver;
+-
+-    p = ngx_resolver_alloc(ctx->resolver, r->ipv6 ? len * 2 : len);
++    p = ngx_resolver_alloc(r, r->ipv6 ? len * 2 : len);
+ #else
+-    p = ngx_resolver_alloc(ctx->resolver, len);
++    p = ngx_resolver_alloc(r, len);
+ #endif
+     if (p == NULL) {
+         return NGX_ERROR;
+@@ -2535,8 +2576,8 @@ ngx_resolver_create_name_query(ngx_resol
+ 
+     ident = ngx_random();
+ 
+-    ngx_log_debug2(NGX_LOG_DEBUG_CORE, ctx->resolver->log, 0,
+-                   "resolve: \"%V\" A %i", &ctx->name, ident & 0xffff);
++    ngx_log_debug2(NGX_LOG_DEBUG_CORE, r->log, 0,
++                   "resolve: \"%V\" A %i", name, ident & 0xffff);
+ 
+     query->ident_hi = (u_char) ((ident >> 8) & 0xff);
+     query->ident_lo = (u_char) (ident & 0xff);
+@@ -2566,11 +2607,11 @@ ngx_resolver_create_name_query(ngx_resol
+     p--;
+     *p-- = '\0';
+ 
+-    if (ctx->name.len == 0)  {
++    if (name->len == 0)  {
+         return NGX_DECLINED;
+     }
+ 
+-    for (s = ctx->name.data + ctx->name.len - 1; s >= ctx->name.data; s--) {
++    for (s = name->data + name->len - 1; s >= name->data; s--) {
+         if (*s != '.') {
+             *p = *s;
+             len++;
+@@ -2606,8 +2647,8 @@ ngx_resolver_create_name_query(ngx_resol
+ 
+     ident = ngx_random();
+ 
+-    ngx_log_debug2(NGX_LOG_DEBUG_CORE, ctx->resolver->log, 0,
+-                   "resolve: \"%V\" AAAA %i", &ctx->name, ident & 0xffff);
++    ngx_log_debug2(NGX_LOG_DEBUG_CORE, r->log, 0,
++                   "resolve: \"%V\" AAAA %i", name, ident & 0xffff);
+ 
+     query->ident_hi = (u_char) ((ident >> 8) & 0xff);
+     query->ident_lo = (u_char) (ident & 0xff);
+@@ -2624,11 +2665,12 @@ ngx_resolver_create_name_query(ngx_resol
+ 
+ 
+ static ngx_int_t
+-ngx_resolver_create_addr_query(ngx_resolver_node_t *rn, ngx_resolver_ctx_t *ctx)
++ngx_resolver_create_addr_query(ngx_resolver_t *r, ngx_resolver_node_t *rn,
++    ngx_addr_t *addr)
+ {
+     u_char               *p, *d;
+     size_t                len;
+-    in_addr_t             addr;
++    in_addr_t             inaddr;
+     ngx_int_t             n;
+     ngx_uint_t            ident;
+     ngx_resolver_hdr_t   *query;
+@@ -2637,7 +2679,7 @@ ngx_resolver_create_addr_query(ngx_resol
+     struct sockaddr_in6  *sin6;
+ #endif
+ 
+-    switch (ctx->addr.sockaddr->sa_family) {
++    switch (addr->sockaddr->sa_family) {
+ 
+ #if (NGX_HAVE_INET6)
+     case AF_INET6:
+@@ -2654,7 +2696,7 @@ ngx_resolver_create_addr_query(ngx_resol
+               + sizeof(ngx_resolver_qs_t);
+     }
+ 
+-    p = ngx_resolver_alloc(ctx->resolver, len);
++    p = ngx_resolver_alloc(r, len);
+     if (p == NULL) {
+         return NGX_ERROR;
+     }
+@@ -2678,11 +2720,11 @@ ngx_resolver_create_addr_query(ngx_resol
+ 
+     p += sizeof(ngx_resolver_hdr_t);
+ 
+-    switch (ctx->addr.sockaddr->sa_family) {
++    switch (addr->sockaddr->sa_family) {
+ 
+ #if (NGX_HAVE_INET6)
+     case AF_INET6:
+-        sin6 = (struct sockaddr_in6 *) ctx->addr.sockaddr;
++        sin6 = (struct sockaddr_in6 *) addr->sockaddr;
+ 
+         for (n = 15; n >= 0; n--) {
+             p = ngx_sprintf(p, "\1%xd\1%xd",
+@@ -2697,11 +2739,11 @@ ngx_resolver_create_addr_query(ngx_resol
+ 
+     default: /* AF_INET */
+ 
+-        sin = (struct sockaddr_in *) ctx->addr.sockaddr;
+-        addr = ntohl(sin->sin_addr.s_addr);
++        sin = (struct sockaddr_in *) addr->sockaddr;
++        inaddr = ntohl(sin->sin_addr.s_addr);
+ 
+         for (n = 0; n < 32; n += 8) {
+-            d = ngx_sprintf(&p[1], "%ud", (addr >> n) & 0xff);
++            d = ngx_sprintf(&p[1], "%ud", (inaddr >> n) & 0xff);
+             *p = (u_char) (d - &p[1]);
+             p = d;
+         }
+@@ -2815,21 +2857,13 @@ done:
+ static void
+ ngx_resolver_timeout_handler(ngx_event_t *ev)
+ {
+-    ngx_resolver_ctx_t   *ctx, *next;
+-    ngx_resolver_node_t  *rn;
++    ngx_resolver_ctx_t  *ctx;
+ 
+-    rn = ev->data;
+-    ctx = rn->waiting;
+-    rn->waiting = NULL;
++    ctx = ev->data;
+ 
+-    do {
+-        ctx->state = NGX_RESOLVE_TIMEDOUT;
+-        next = ctx->next;
+-
+-        ctx->handler(ctx);
++    ctx->state = NGX_RESOLVE_TIMEDOUT;
+ 
+-        ctx = next;
+-    } while (ctx);
++    ctx->handler(ctx);
+ }
+ 
+ 
+diff -upr nginx-1.9.7-old/src/core/ngx_resolver.h nginx-1.9.7/src/core/ngx_resolver.h
+--- nginx-1.9.7-old/src/core/ngx_resolver.h	2016-01-26 11:54:55.914404751 -0800
++++ nginx-1.9.7/src/core/ngx_resolver.h	2016-01-26 11:55:27.068784001 -0800
+@@ -51,15 +51,11 @@ typedef void (*ngx_resolver_handler_pt)(
+ 
+ 
+ typedef struct {
+-    /* PTR: resolved name, A: name to resolve */
+-    u_char                   *name;
+-
++    ngx_rbtree_node_t         node;
+     ngx_queue_t               queue;
+ 
+-    /* event ident must be after 3 pointers as in ngx_connection_t */
+-    ngx_int_t                 ident;
+-
+-    ngx_rbtree_node_t         node;
++    /* PTR: resolved name, A: name to resolve */
++    u_char                   *name;
+ 
+ #if (NGX_HAVE_INET6)
+     /* PTR: IPv6 address to resolve (IPv4 address is in rbtree node key) */
+@@ -147,6 +143,9 @@ struct ngx_resolver_ctx_s {
+     ngx_resolver_t           *resolver;
+     ngx_udp_connection_t     *udp_connection;
+ 
++    /* event ident must be after 3 pointers as in ngx_connection_t */
++    ngx_int_t                 ident;
++
+     ngx_int_t                 state;
+     ngx_str_t                 name;
+ 
+@@ -162,6 +161,8 @@ struct ngx_resolver_ctx_s {
+     ngx_uint_t                quick;  /* unsigned  quick:1; */
+     ngx_uint_t                recursion;
+     ngx_event_t              *event;
++
++    ngx_resolver_node_t      *node;
+ };
+ 
+ 

patches/nginx-1.9.7-ssl_cert_cb_yield.patch

@@ -0,0 +1,42 @@
+# HG changeset patch
+# User Yichun Zhang <agentzh@openresty.org>
+# Date 1451762084 28800
+#      Sat Jan 02 11:14:44 2016 -0800
+# Node ID 449f0461859c16e95bdb18e8be6b94401545d3dd
+# Parent  78b4e10b4367b31367aad3c83c9c3acdd42397c4
+SSL: handled SSL_CTX_set_cert_cb() callback yielding.
+
+OpenSSL 1.0.2+ introduces SSL_CTX_set_cert_cb() to allow custom
+callbacks to serve the SSL certificiates and private keys dynamically
+and lazily. The callbacks may yield for nonblocking I/O or sleeping.
+Here we added support for such usage in NGINX 3rd-party modules
+(like ngx_lua) in NGINX's event handlers for downstream SSL
+connections.
+
+diff -r 78b4e10b4367 -r 449f0461859c src/event/ngx_event_openssl.c
+--- a/src/event/ngx_event_openssl.c	Thu Dec 17 16:39:15 2015 +0300
++++ b/src/event/ngx_event_openssl.c	Sat Jan 02 11:14:44 2016 -0800
+@@ -1210,6 +1210,23 @@
+         return NGX_AGAIN;
+     }
+ 
++#if OPENSSL_VERSION_NUMBER >= 0x10002000L
++    if (sslerr == SSL_ERROR_WANT_X509_LOOKUP) {
++        c->read->handler = ngx_ssl_handshake_handler;
++        c->write->handler = ngx_ssl_handshake_handler;
++
++        if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
++            return NGX_ERROR;
++        }
++
++        if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
++            return NGX_ERROR;
++        }
++
++        return NGX_AGAIN;
++    }
++#endif
++
+     err = (sslerr == SSL_ERROR_SYSCALL) ? ngx_errno : 0;
+ 
+     c->ssl->no_wait_shutdown = 1;

patches/patch.2016.write2.txt

@@ -0,0 +1,15 @@
+--- src/os/unix/ngx_files.c
++++ src/os/unix/ngx_files.c
+@@ -183,6 +183,12 @@ ngx_write_chain_to_file(ngx_file_t *file
+         /* create the iovec and coalesce the neighbouring bufs */
+ 
+         while (cl && vec.nelts < IOV_MAX) {
++
++            if (ngx_buf_special(cl->buf)) {
++                cl = cl->next;
++                continue;
++            }
++
+             if (prev == cl->buf->pos) {
+                 iov->iov_len += cl->buf->last - cl->buf->pos;
+ 

specs/openresty.spec

@@ -4,7 +4,7 @@
 
 %define         dir_name      openresty
 
-Name:		ngx_openresty
+Name:		openresty
 
 Version:	1.0.5.1
 Release:	5
@@ -14,7 +14,7 @@ Group:		Productivity/Networking/Web/Servers
 License:	BSD
 URL:		http://www.openresty.org/
 
-Source0:	ngx_openresty-%{version}rc%{release}.tar.gz
+Source0:	openresty-%{version}rc%{release}.tar.gz
 
 BuildRoot:	%{build_root}
 
@@ -23,11 +23,11 @@ BuildRequires:	gcc >= 3.0, openssl-devel, pcre-devel, readline-devel
 Requires:	openssl, pcre, readline
 
 %description
-OpenResty (aka. ngx_openresty) is a full-fledged web application server by bundling the standard Nginx core, lots of 3rd-party Nginx modules, as well as most of their external dependencie
+OpenResty is a full-fledged web application server by bundling the standard Nginx core, lots of 3rd-party Nginx modules, as well as most of their external dependencie
 
 %prep
-#%setup -q -n ngx_openresty-%{version}
-%setup -q -n ngx_openresty-%{version}rc%{release}
+#%setup -q -n openresty-%{version}
+%setup -q -n openresty-%{version}rc%{release}
 
 %build
             #--with-pg_config=opt/pg90/bin/pg_config \

t/Config.pm

@@ -23,7 +23,7 @@ sub run_tests {
     my $ver = `bash util/ver`;
     chomp $ver;
 
-    cd "ngx_openresty-$ver";
+    cd "openresty-$ver";
 
     $DistRoot = cwd();
     $BuildRoot = File::Spec->rel2abs("./build");

util/configure

@@ -767,8 +767,8 @@ _END_
             print $in <<"_EOC_";
 
 ngx_lua_dquote='"'
-CFLAGS="\$CFLAGS -DLUA_DEFAULT_PATH='\$ngx_lua_dquote$path_prefix/?.lua;$path_prefix/?/init.lua\$ngx_lua_dquote'"
-CFLAGS="\$CFLAGS -DLUA_DEFAULT_CPATH='\$ngx_lua_dquote$path_prefix/?.so\$ngx_lua_dquote'"
+CFLAGS="\$CFLAGS -DLUA_DEFAULT_PATH='\${ngx_lua_dquote}$path_prefix/?.lua;$path_prefix/?/init.lua\$ngx_lua_dquote'"
+CFLAGS="\$CFLAGS -DLUA_DEFAULT_CPATH='\${ngx_lua_dquote}$path_prefix/?.so\$ngx_lua_dquote'"
 _EOC_
         }
 

util/dist-check

@@ -15,7 +15,7 @@ getopts("lf:", \%opts) or die "Usage: $0 [-f] [-l] <cores>\n";
 my $jobs = shift || 4;
 
 my $cwd = cwd();
-if ($cwd !~ /ngx_openresty-(\d+(?:\.\d+)+(?:rc\d+(?:\.\d+)?)?)$/) {
+if ($cwd !~ /openresty-(\d+(?:\.\d+)+(?:rc\d+(?:\.\d+)?)?)$/) {
     die "Bad current working directory: $cwd\n";
 }
 
@@ -46,8 +46,10 @@ if ($^O eq 'solaris') {
 }
 
 if ($^O eq 'darwin') {
-    $cfg_opts .= " --with-cc-opt='-I/usr/local/include'"
-               . " --with-ld-opt='-L/usr/local/lib'";
+    $cfg_opts .= " --with-cc-opt='-I/usr/local/opt/openssl/include/ "
+               . "-I/usr/local/opt/pcre/include/'"
+               . " --with-ld-opt='-L/usr/local/opt/openssl/lib/ "
+               . "-L/usr/local/opt/pcre/lib/'";
 }
 
 my $prefix;
@@ -65,6 +67,45 @@ sub write_config_file ($) {
 
 write_config_file "/tmp/nginx.conf";
 
+warn "=== --with-stream ===\n";
+$prefix = "/usr/local/openresty-nogzip";
+sh "sudo rm -rf $prefix/lualib $prefix/luajit $prefix/bin $prefix/lua $prefix/nginx/sbin $prefix/nginx/html";
+unless ($opts{f}) {
+    sh "./configure $cfg_opts --with-stream --prefix=$prefix -j$jobs > /dev/null";
+}
+sh "$make -j$jobs > /dev/null";
+sh "sudo $make install > /dev/null";
+sh "sudo cp /tmp/nginx.conf $prefix/nginx/conf/nginx.conf";
+sh "$prefix/nginx/sbin/nginx -V 2>&1 |grep $ver";
+sh "$prefix/nginx/sbin/nginx -V 2>&1 |grep '\\--with-stream'";
+system "sudo killall nginx > /dev/null 2>&1";
+sh "sudo $prefix/nginx/sbin/nginx";
+sh "curl -si localhost/lua|grep $lua";
+sh "curl -si localhost/lua|grep $ver";
+sh "curl -si localhost/cjson|grep 'json.safe: '";
+sh qq{$prefix/bin/resty -e 'ngx.say("Hello World!")'|grep 'Hello World'};
+sh "sudo $prefix/nginx/sbin/nginx -sstop";
+
+warn "=== --with-stream + dtrace static probes ===\n";
+$prefix = "/usr/local/openresty-nogzip";
+sh "sudo rm -rf $prefix/lualib $prefix/luajit $prefix/bin $prefix/lua $prefix/nginx/sbin $prefix/nginx/html";
+unless ($opts{f}) {
+    sh "./configure $cfg_opts --with-dtrace-probes --with-stream --prefix=$prefix -j$jobs > /dev/null";
+}
+sh "$make -j$jobs > /dev/null";
+sh "sudo $make install > /dev/null";
+sh "sudo cp /tmp/nginx.conf $prefix/nginx/conf/nginx.conf";
+sh "$prefix/nginx/sbin/nginx -V 2>&1 |grep $ver";
+sh "$prefix/nginx/sbin/nginx -V 2>&1 |grep '\\--with-stream'";
+sh "$prefix/nginx/sbin/nginx -V 2>&1 |grep '\\--with-dtrace-probes'";
+system "sudo killall nginx > /dev/null 2>&1";
+sh "sudo $prefix/nginx/sbin/nginx";
+sh "curl -si localhost/lua|grep $lua";
+sh "curl -si localhost/lua|grep $ver";
+sh "curl -si localhost/cjson|grep 'json.safe: '";
+sh qq{$prefix/bin/resty -e 'ngx.say("Hello World!")'|grep 'Hello World'};
+sh "sudo $prefix/nginx/sbin/nginx -sstop";
+
 warn "=== Without Gzip/SSL/PCRE ===\n";
 $prefix = "/usr/local/openresty-nogzip";
 sh "sudo rm -rf $prefix/lualib $prefix/luajit $prefix/bin $prefix/lua $prefix/nginx/sbin $prefix/nginx/html";
@@ -221,6 +262,13 @@ http {
         end
     ';
 
+    upstream backend {
+        server 0.0.0.1;
+        balancer_by_lua_block {
+            print("balancer!")
+        }
+    }
+
     server {
         listen       *:80;
         server_name  localhost;

util/fix-tests

@@ -8,7 +8,7 @@ sub cd ($);
 my $ver = `bash util/ver`;
 chomp $ver;
 
-cd "ngx_openresty-$ver/bundle";
+cd "openresty-$ver/bundle";
 
 opendir(my $dh, '.') or
     die "cannot opendir .: $!";
@@ -45,7 +45,7 @@ for my $t_file (@t_files) {
                 warn "\n- $orig";
                 warn "+ $_";
 
-            } elsif (s{ngx_openresty-\d+\.\d+\.\d+\.\d+(?:rc\d+)?}{ngx_openresty-$ver} && $orig ne $_) {
+            } elsif (s{openresty-\d+\.\d+\.\d+\.\d+(?:rc\d+)?}{openresty-$ver} && $orig ne $_) {
                 $changed++;
 
                 warn "\n- $orig";

util/get-tarball

@@ -14,7 +14,7 @@ cachefile=$work/$outfile
 if [ -s $cachefile ]; then
     cp $work/$outfile $outfile || exit 1
 else
-    wget --no-check-certificate $1 -O $3 || exit 1
+    wget $1 -O $3 || exit 1
     if [ $? == 0 ]; then
         cp $3 $work/ || exit 1
     fi

util/mirror-tarballs

@@ -5,11 +5,11 @@ root=`perl -MCwd -e'print Cwd::abs_path(shift)' $(dirname -- "$0")/..`
 
 info_txt=`perl -e 'print "\033[33m[INFO]\033[0m"'`
 
-echo -n "ngx_openresty "
+echo -n "openresty "
 . ./util/ver
 echo
 
-name=ngx_openresty-$version
+name=openresty-$version
 work=$root/work
 
 if [ -z $debug ]; then
@@ -26,7 +26,7 @@ fi
 #################################
 
 ver="$main_ver"
-$root/util/get-tarball "http://openresty.org/download/nginx-$ver.tar.gz" -O nginx-$ver.tar.gz || exit 1
+$root/util/get-tarball "https://openresty.org/download/nginx-$ver.tar.gz" -O nginx-$ver.tar.gz || exit 1
 tar -xzf nginx-$ver.tar.gz || exit 1
 cd nginx-$ver || exit 1
 
@@ -39,6 +39,13 @@ if [ "$answer" = "N" ]; then
     echo
 fi
 
+answer=`$root/util/ver-ge "$main_ver" 1.9.12`
+if [ "$answer" = "N" ]; then
+    echo "$info_txt applying the patch for nginx security advisory (CVE-2016-4450)"
+    patch -p0 < $root/patches/patch.2016.write2.txt || exit 1
+    echo
+fi
+
 echo "$info_txt applying the upstream-pipelining patch for nginx"
 patch -p1 < $root/patches/nginx-$main_ver-upstream_pipelining.patch || exit 1
 echo
@@ -293,12 +300,22 @@ if [ "$answer" = "N" ]; then
     echo
 fi
 
+if [ "$main_ver" = "1.9.7" ]; then
+    echo "$info_txt applying the resolver_security_fixes patch for nginx"
+    patch -p1 < $root/patches/nginx-$main_ver-resolver_security_fixes.patch || exit 1
+    echo
+fi
+
 rm -f *.patch || exit 1
 
 echo "$info_txt applying the always_enable_cc_feature_tests patch to nginx"
 patch -p1 < $root/patches/nginx-$main_ver-always_enable_cc_feature_tests.patch
 echo
 
+echo "$info_txt applying the ssl_cert_cb_yield.patch patch to nginx"
+patch -p1 < $root/patches/nginx-$main_ver-ssl_cert_cb_yield.patch
+echo
+
 cd .. || exit 1
 
 cp $root/patches/nginx-$main_ver-no_pool.patch ./nginx-no_pool.patch || exit 1
@@ -331,7 +348,7 @@ mv simpl-ngx_devel_kit-* ngx_devel_kit-$ver || exit 1
 
 #################################
 
-ver=0.29
+ver=0.30
 $root/util/get-tarball "https://github.com/openresty/set-misc-nginx-module/tarball/v$ver" -O set-misc-nginx-module-$ver.tar.gz || exit 1
 tar -xzf set-misc-nginx-module-$ver.tar.gz || exit 1
 mv openresty-set-misc-nginx-module-* set-misc-nginx-module-$ver || exit 1
@@ -366,21 +383,21 @@ mv openresty-drizzle-nginx-module-* drizzle-nginx-module-$ver || exit 1
 
 #################################
 
-ver=0.9.20
+ver=0.10.2
 $root/util/get-tarball "https://github.com/openresty/lua-nginx-module/tarball/v$ver" -O lua-nginx-module-$ver.tar.gz || exit 1
 tar -xzf lua-nginx-module-$ver.tar.gz || exit 1
 mv openresty-lua-nginx-module-* ngx_lua-$ver || exit 1
 
 #################################
 
-ver=0.04
+ver=0.05
 $root/util/get-tarball "https://github.com/openresty/lua-upstream-nginx-module/tarball/v$ver" -O lua-upstream-nginx-module-$ver.tar.gz || exit 1
 tar -xzf lua-upstream-nginx-module-$ver.tar.gz || exit 1
 mv openresty-lua-upstream-nginx-module-* ngx_lua_upstream-$ver || exit 1
 
 #################################
 
-ver=0.04
+ver=0.05
 $root/util/get-tarball "https://github.com/openresty/array-var-nginx-module/tarball/v$ver" -O array-var-nginx-module-$ver.tar.gz || exit 1
 tar -xzf array-var-nginx-module-$ver.tar.gz || exit 1
 mv openresty-array-var-nginx-module-* array-var-nginx-module-$ver || exit 1
@@ -431,7 +448,7 @@ mv openresty-encrypted-session-nginx-module-* encrypted-session-nginx-module-$ve
 #################################
 
 ver=0.3.7
-$root/util/get-tarball "http://people.freebsd.org/~osa/ngx_http_redis-$ver.tar.gz" -O redis-nginx-module-$ver.tar.gz || exit 1
+$root/util/get-tarball "https://people.freebsd.org/~osa/ngx_http_redis-$ver.tar.gz" -O redis-nginx-module-$ver.tar.gz || exit 1
 tar -xzf redis-nginx-module-$ver.tar.gz || exit 1
 mv ngx_http_redis-* redis-nginx-module-$ver || exit 1
 
@@ -468,7 +485,7 @@ mv openresty-redis2-nginx-module-* redis2-nginx-module-$ver || exit 1
 
 #################################
 
-ver=0.05
+ver=0.06
 $root/util/get-tarball "https://github.com/openresty/resty-cli/tarball/v$ver" -O resty-cli-$ver.tar.gz || exit 1
 tar -xzf resty-cli-$ver.tar.gz || exit 1
 mv openresty-resty-cli-* resty-cli-$ver || exit 1
@@ -501,7 +518,7 @@ echo
 
 #################################
 
-ver=2.1-20151219
+ver=2.1-20160108
 $root/util/get-tarball "https://github.com/openresty/luajit2/archive/v$ver.tar.gz" -O "LuaJIT-$ver.tar.gz" || exit 1
 tar -xzf LuaJIT-$ver.tar.gz || exit 1
 mv luajit2-* LuaJIT-$ver || exit 1
@@ -557,7 +574,7 @@ cd ..
 
 #################################
 
-ver=0.14
+ver=0.15
 $root/util/get-tarball "https://github.com/openresty/lua-resty-dns/tarball/v$ver" -O "lua-resty-dns-$ver.tar.gz" || exit 1
 tar -xzf lua-resty-dns-$ver.tar.gz || exit 1
 mv openresty-lua-resty-dns-* lua-resty-dns-$ver || exit 1
@@ -665,7 +682,7 @@ cd ..
 
 #################################
 
-ver=0.1.3
+ver=0.1.5
 $root/util/get-tarball "https://github.com/openresty/lua-resty-core/tarball/v$ver" -O "lua-resty-core-$ver.tar.gz" || exit 1
 tar -xzf lua-resty-core-$ver.tar.gz || exit 1
 mv openresty-lua-resty-core-* lua-resty-core-$ver || exit 1
@@ -677,7 +694,7 @@ mv openresty-lua-resty-core-* lua-resty-core-$ver || exit 1
 
 #################################
 
-ver=0.03
+ver=0.04
 $root/util/get-tarball "https://github.com/openresty/lua-resty-upstream-healthcheck/tarball/v$ver" -O "lua-resty-upstream-healthcheck-$ver.tar.gz" || exit 1
 tar -xzf lua-resty-upstream-healthcheck-$ver.tar.gz || exit 1
 mv openresty-lua-resty-upstream-healthcheck-* lua-resty-upstream-healthcheck-$ver || exit 1

util/package-nginx.sh

@@ -31,4 +31,4 @@ cd ..
 tar czvf nginx-$ver.tar.gz nginx-$ver || exit 1
 ls -lh ./nginx-$ver.tar.gz
 #ls -lh ~/work/nginx-$ver.tar.gz
-scp nginx-$ver.tar.gz agentzh.org:~/www/agentzh/misc/nginx/
+scp nginx-$ver.tar.gz openresty.org:/home/agentz/www/agentzh/misc/nginx/

util/ver

@@ -1,7 +1,7 @@
 #!/bin/bash
 
 main_ver=1.9.7
-minor_ver=1
+minor_ver=5
 version=$main_ver.$minor_ver
 echo $version