updated tests to reflect recent changes.

This reverts commit 6c14ea5c56.

README

@@ -1,83 +0,0 @@
-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 dependencies.
-
-This bundle is maintained by us, agentzh and chaoslawful, and sponsored by
-Taobao.com, Alibaba Group.
-
-Because most of the nginx modules are developed by the bundle maintainers, it can ensure
-that all these modules are played well together.
-
-The bundled software components are copyrighted by the respective copyright holders.
-
-The homepage for this project is http://openresty.org.
-
-For users:
-    Visit http://openresty.org/#Download to download the latest bundle tarball, and
-    follow the installation instructions in the page http://openresty.org/#Installation.
-
-For bundle maintainers:
-
-    The bundle's source is at the following git repository:
-
-        https://github.com/agentzh/ngx_openresty
-
-    To reproduce the bundle tarball, just do
-
-        make
-
-    at the top of the bundle source tree.
-
-MAILING LIST
-    You're very welcome to join the English OpenResty mailing list hosted on
-    Google Groups:
-
-        https://groups.google.com/group/openresty-en
-
-    The Chinese mailing list is here:
-
-        https://groups.google.com/group/openresty
-
-REPORT BUGS
-
-You're very welcome to report issues on GitHub:
-
-    https://github.com/agentzh/ngx_openresty/issues
-
-COPYRIGHT & LICENSE
-
-The bundle itself is licensed under the 2-clause BSD license.
-
-    Copyright (c) 2011, Taobao Inc., Alibaba Group (
-    http://www.taobao.com ).
-
-    Copyright (c) 2011, Yichun "agentzh" Zhang (章亦春)
-    <agentzh@gmail.com>.
-
-    Copyright (c) 2011, Xiaozhe "chaoslawful" Wang (王晓哲)
-    <chaoslawful@gmail.com>.
-
-    This module is licensed under the terms of the BSD license.
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are
-    met:
-
-    *   Redistributions of source code must retain the above copyright
-        notice, this list of conditions and the following disclaimer.
-
-    *   Redistributions in binary form must reproduce the above copyright
-        notice, this list of conditions and the following disclaimer in the
-        documentation and/or other materials provided with the distribution.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-    HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
-    TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-

README.markdown

@@ -0,0 +1,85 @@
+Name
+====
+
+ngx_openresty - Turning Nginx into a full-fledged Web App Server
+
+Description
+===========
+
+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 dependencies.
+
+This bundle is maintained Yichun Zhang (agentzh).
+
+Because most of the nginx modules are developed by the bundle maintainers, it can ensure
+that all these modules are played well together.
+
+The bundled software components are copyrighted by the respective copyright holders.
+
+The homepage for this project is http://openresty.org.
+
+For Users
+---------
+
+Visit http://openresty.org/#Download to download the latest bundle tarball, and
+follow the installation instructions in the page http://openresty.org/#Installation.
+
+For Bundle Maintainers
+----------------------
+
+The bundle's source is at the following git repository:
+
+    https://github.com/agentzh/ngx_openresty
+
+To reproduce the bundle tarball, just do
+
+    make
+
+at the top of the bundle source tree.
+
+Mailing List
+============
+
+You're very welcome to join the English OpenResty mailing list hosted on Google Groups:
+
+    https://groups.google.com/group/openresty-en
+
+The Chinese mailing list is here:
+
+    https://groups.google.com/group/openresty
+
+Report Bugs
+===========
+
+You're very welcome to report issues on GitHub:
+
+    https://github.com/agentzh/ngx_openresty/issues
+
+Copyright & License
+===================
+
+The bundle itself is licensed under the 2-clause BSD license.
+
+Copyright (c) 2011-2013, Yichun "agentzh" Zhang (章亦春) <agentzh@gmail.com>, CloudFlare Inc.
+
+This module is licensed under the terms of the BSD license.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

patches/lua-5.1.5-enable_debug_info.patch

@@ -0,0 +1,11 @@
+--- lua-5.1.5/src/Makefile	2012-02-13 12:41:22.000000000 -0800
++++ lua-5.1.5-patched/src/Makefile	2013-04-20 22:56:42.921286886 -0700
+@@ -8,7 +8,7 @@
+ PLAT= none
+ 
+ CC= gcc
+-CFLAGS= -O2 -Wall $(MYCFLAGS)
++CFLAGS= -g -O2 -Wall $(MYCFLAGS)
+ AR= ar rcu
+ RANLIB= ranlib
+ RM= rm -f

patches/luajit-2.0.0-2ad9834d.patch

@@ -0,0 +1,202 @@
+diff --git a/doc/ext_ffi_semantics.html b/doc/ext_ffi_semantics.html
+index bf9f9be..30aa964 100644
+--- a/doc/ext_ffi_semantics.html
++++ b/doc/ext_ffi_semantics.html
+@@ -517,17 +517,17 @@ A VLA is only initialized with the element(s) given in the table.
+ Depending on the use case, you may need to explicitly add a
+ <tt>NULL</tt> or <tt>0</tt> terminator to a VLA.</li>
+ 
+-<li>If the table has a non-empty hash part, a
+-<tt>struct</tt>/<tt>union</tt> is initialized by looking up each field
+-name (as a string key) in the table. Each non-<tt>nil</tt> value is
+-used to initialize the corresponding field.</li>
+-
+-<li>Otherwise a <tt>struct</tt>/<tt>union</tt> is initialized in the
++<li>A <tt>struct</tt>/<tt>union</tt> can be initialized in the
+ order of the declaration of its fields. Each field is initialized with
+-the consecutive table elements, starting at either index <tt>[0]</tt>
++consecutive table elements, starting at either index <tt>[0]</tt>
+ or <tt>[1]</tt>. This process stops at the first <tt>nil</tt> table
+ element.</li>
+ 
++<li>Otherwise, if neither index <tt>[0]</tt> nor <tt>[1]</tt> is present,
++a <tt>struct</tt>/<tt>union</tt> is initialized by looking up each field
++name (as a string key) in the table. Each non-<tt>nil</tt> value is
++used to initialize the corresponding field.</li>
++
+ <li>Uninitialized fields of a <tt>struct</tt> are filled with zero
+ bytes, except for the trailing VLA of a VLS.</li>
+ 
+diff --git a/doc/running.html b/doc/running.html
+index 7870a5d..97c5c03 100644
+--- a/doc/running.html
++++ b/doc/running.html
+@@ -250,6 +250,8 @@ are enabled:
+ <tr class="even">
+ <td class="flag_name">abc</td><td class="flag_level">&nbsp;</td><td class="flag_level">&nbsp;</td><td class="flag_level">&bull;</td><td class="flag_desc">Array Bounds Check Elimination</td></tr>
+ <tr class="odd">
++<td class="flag_name">sink</td><td class="flag_level">&nbsp;</td><td class="flag_level">&nbsp;</td><td class="flag_level">&bull;</td><td class="flag_desc">Allocation/Store Sinking</td></tr>
++<tr class="even">
+ <td class="flag_name">fuse</td><td class="flag_level">&nbsp;</td><td class="flag_level">&nbsp;</td><td class="flag_level">&bull;</td><td class="flag_desc">Fusion of operands into instructions</td></tr>
+ </table>
+ <p>
+diff --git a/src/lj_arch.h b/src/lj_arch.h
+index 25c2cff..220f3df 100644
+--- a/src/lj_arch.h
++++ b/src/lj_arch.h
+@@ -300,7 +300,11 @@
+ 
+ /* Check target-specific constraints. */
+ #ifndef _BUILDVM_H
+-#if LJ_TARGET_ARM
++#if LJ_TARGET_X64
++#if __USING_SJLJ_EXCEPTIONS__
++#error "Need a C compiler with native exception handling on x64"
++#endif
++#elif LJ_TARGET_ARM
+ #if defined(__ARMEB__)
+ #error "No support for big-endian ARM"
+ #endif
+diff --git a/src/lj_asm_x86.h b/src/lj_asm_x86.h
+index 6d7dd5a..241da5a 100644
+--- a/src/lj_asm_x86.h
++++ b/src/lj_asm_x86.h
+@@ -367,6 +367,18 @@ static Reg asm_fuseload(ASMState *as, IRRef ref, RegSet allow)
+   return ra_allocref(as, ref, allow);
+ }
+ 
++#if LJ_64
++/* Don't fuse a 32 bit load into a 64 bit operation. */
++static Reg asm_fuseloadm(ASMState *as, IRRef ref, RegSet allow, int is64)
++{
++  if (is64 && !irt_is64(IR(ref)->t))
++    return ra_alloc1(as, ref, allow);
++  return asm_fuseload(as, ref, allow);
++}
++#else
++#define asm_fuseloadm(as, ref, allow, is64)  asm_fuseload(as, (ref), (allow))
++#endif
++
+ /* -- Calls --------------------------------------------------------------- */
+ 
+ /* Count the required number of stack slots for a call. */
+@@ -696,7 +708,7 @@ static void asm_conv(ASMState *as, IRIns *ir)
+     } else {  /* Integer to FP conversion. */
+       Reg left = (LJ_64 && (st == IRT_U32 || st == IRT_U64)) ?
+ 		 ra_alloc1(as, lref, RSET_GPR) :
+-		 asm_fuseload(as, lref, RSET_GPR);
++		 asm_fuseloadm(as, lref, RSET_GPR, st64);
+       if (LJ_64 && st == IRT_U64) {
+ 	MCLabel l_end = emit_label(as);
+ 	const void *k = lj_ir_k64_find(as->J, U64x(43f00000,00000000));
+@@ -1829,7 +1841,7 @@ static void asm_intarith(ASMState *as, IRIns *ir, x86Arith xa)
+     if (asm_swapops(as, ir)) {
+       IRRef tmp = lref; lref = rref; rref = tmp;
+     }
+-    right = asm_fuseload(as, rref, rset_clear(allow, dest));
++    right = asm_fuseloadm(as, rref, rset_clear(allow, dest), irt_is64(ir->t));
+   }
+   if (irt_isguard(ir->t))  /* For IR_ADDOV etc. */
+     asm_guardcc(as, CC_O);
+@@ -1842,7 +1854,7 @@ static void asm_intarith(ASMState *as, IRIns *ir, x86Arith xa)
+     emit_mrm(as, XO_IMUL, REX_64IR(ir, dest), right);
+   } else {  /* IMUL r, r, k. */
+     /* NYI: use lea/shl/add/sub (FOLD only does 2^k) depending on CPU. */
+-    Reg left = asm_fuseload(as, lref, RSET_GPR);
++    Reg left = asm_fuseloadm(as, lref, RSET_GPR, irt_is64(ir->t));
+     x86Op xo;
+     if (checki8(k)) { emit_i8(as, k); xo = XO_IMULi8;
+     } else { emit_i32(as, k); xo = XO_IMULi; }
+@@ -2072,7 +2084,7 @@ static void asm_comp(ASMState *as, IRIns *ir, uint32_t cc)
+     Reg r64 = REX_64IR(ir, 0);
+     int32_t imm = 0;
+     lua_assert(irt_is64(ir->t) || irt_isint(ir->t) ||
+-	       irt_isu32(ir->t) || irt_isaddr(ir->t));
++	       irt_isu32(ir->t) || irt_isaddr(ir->t) || irt_isu8(ir->t));
+     /* Swap constants (only for ABC) and fusable loads to the right. */
+     if (irref_isk(lref) || (!irref_isk(rref) && opisfusableload(leftop))) {
+       if ((cc & 0xc) == 0xc) cc ^= 0x53;  /* L <-> G, LE <-> GE */
+@@ -2109,7 +2121,7 @@ static void asm_comp(ASMState *as, IRIns *ir, uint32_t cc)
+ 	  }
+ 	}
+ 	as->curins--;  /* Skip to BAND to avoid failing in noconflict(). */
+-	right = asm_fuseload(as, irl->op1, allow);
++	right = asm_fuseloadm(as, irl->op1, allow, r64);
+ 	as->curins++;  /* Undo the above. */
+       test_nofuse:
+ 	asm_guardcc(as, cc);
+@@ -2146,7 +2158,7 @@ static void asm_comp(ASMState *as, IRIns *ir, uint32_t cc)
+ 	    return;
+ 	  }  /* Otherwise handle register case as usual. */
+ 	} else {
+-	  left = asm_fuseload(as, lref, RSET_GPR);
++	  left = asm_fuseloadm(as, lref, RSET_GPR, r64);
+ 	}
+ 	asm_guardcc(as, cc);
+ 	if (usetest && left != RID_MRM) {
+@@ -2160,7 +2172,7 @@ static void asm_comp(ASMState *as, IRIns *ir, uint32_t cc)
+       }
+     } else {
+       Reg left = ra_alloc1(as, lref, RSET_GPR);
+-      Reg right = asm_fuseload(as, rref, rset_exclude(RSET_GPR, left));
++      Reg right = asm_fuseloadm(as, rref, rset_exclude(RSET_GPR, left), r64);
+       asm_guardcc(as, cc);
+       emit_mrm(as, XO_CMP, r64 + left, right);
+     }
+diff --git a/src/lj_cconv.c b/src/lj_cconv.c
+index b81b4e9..7b32e35 100644
+--- a/src/lj_cconv.c
++++ b/src/lj_cconv.c
+@@ -493,17 +493,19 @@ static void cconv_substruct_tab(CTState *cts, CType *d, uint8_t *dp,
+     id = df->sib;
+     if (ctype_isfield(df->info) || ctype_isbitfield(df->info)) {
+       TValue *tv;
+-      int32_t i = *ip;
++      int32_t i = *ip, iz = i;
+       if (!gcref(df->name)) continue;  /* Ignore unnamed fields. */
+       if (i >= 0) {
+       retry:
+ 	tv = (TValue *)lj_tab_getint(t, i);
+ 	if (!tv || tvisnil(tv)) {
+ 	  if (i == 0) { i = 1; goto retry; }  /* 1-based tables. */
++	  if (iz == 0) { *ip = i = -1; goto tryname; }  /* Init named fields. */
+ 	  break;  /* Stop at first nil. */
+ 	}
+ 	*ip = i + 1;
+       } else {
++      tryname:
+ 	tv = (TValue *)lj_tab_getstr(t, gco2str(gcref(df->name)));
+ 	if (!tv || tvisnil(tv)) continue;
+       }
+@@ -524,7 +526,6 @@ static void cconv_struct_tab(CTState *cts, CType *d,
+ {
+   int32_t i = 0;
+   memset(dp, 0, d->size);  /* Much simpler to clear the struct first. */
+-  if (t->hmask) i = -1; else if (t->asize == 0) return;  /* Fast exit. */
+   cconv_substruct_tab(cts, d, dp, t, &i, flags);
+ }
+ 
+diff --git a/src/lj_err.c b/src/lj_err.c
+index 60d8fe1..fd3545e 100644
+--- a/src/lj_err.c
++++ b/src/lj_err.c
+@@ -485,7 +485,6 @@ LJ_NOINLINE void lj_err_mem(lua_State *L)
+ {
+   if (L->status == LUA_ERRERR+1)  /* Don't touch the stack during lua_open. */
+     lj_vm_unwind_c(L->cframe, LUA_ERRMEM);
+-  L->top = L->base;
+   setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRMEM));
+   lj_err_throw(L, LUA_ERRMEM);
+ }
+diff --git a/src/lj_parse.c b/src/lj_parse.c
+index 2fecaef..92ebc04 100644
+--- a/src/lj_parse.c
++++ b/src/lj_parse.c
+@@ -1825,6 +1825,7 @@ static void expr_table(LexState *ls, ExpDesc *e)
+ 	}
+       }
+     }
++    lj_gc_check(fs->L);
+   }
+ }
+ 

patches/nginx-1.2.3-allow_request_body_updating.patch

@@ -1,6 +1,6 @@
-diff '--exclude=*~' -ur nginx-1.2.3/src/http/ngx_http_core_module.c nginx-1.2.3-patched/src/http/ngx_http_core_module.c
---- nginx-1.2.3/src/http/ngx_http_core_module.c	2012-06-04 04:58:12.000000000 -0700
-+++ nginx-1.2.3-patched/src/http/ngx_http_core_module.c	2012-07-21 12:09:17.468576485 -0700
+diff -ur nginx-1.2.3/src/http/ngx_http_core_module.c nginx-1.2.3-patched/src/http/ngx_http_core_module.c
+--- nginx-1.2.3/src/http/ngx_http_core_module.c	2012-08-06 10:31:32.000000000 -0700
++++ nginx-1.2.3-patched/src/http/ngx_http_core_module.c	2012-08-30 11:37:42.388213974 -0700
 @@ -2420,6 +2420,8 @@
  
      sr->request_body = r->request_body;
@@ -10,9 +10,9 @@ diff '--exclude=*~' -ur nginx-1.2.3/src/http/ngx_http_core_module.c nginx-1.2.3-
      sr->method = NGX_HTTP_GET;
      sr->http_version = r->http_version;
  
-diff '--exclude=*~' -ur nginx-1.2.3/src/http/ngx_http_request_body.c nginx-1.2.3-patched/src/http/ngx_http_request_body.c
+diff -ur nginx-1.2.3/src/http/ngx_http_request_body.c nginx-1.2.3-patched/src/http/ngx_http_request_body.c
 --- nginx-1.2.3/src/http/ngx_http_request_body.c	2012-04-12 12:35:41.000000000 -0700
-+++ nginx-1.2.3-patched/src/http/ngx_http_request_body.c	2012-07-21 12:08:30.655376967 -0700
++++ nginx-1.2.3-patched/src/http/ngx_http_request_body.c	2012-08-30 11:37:42.388213974 -0700
 @@ -39,7 +39,7 @@
  
      r->main->count++;
@@ -89,10 +89,9 @@ diff '--exclude=*~' -ur nginx-1.2.3/src/http/ngx_http_request_body.c nginx-1.2.3
      }
  }
  
-Only in nginx-1.2.3-patched/src/http: ngx_http_request_body.c.orig
-diff '--exclude=*~' -ur nginx-1.2.3/src/http/ngx_http_request.c nginx-1.2.3-patched/src/http/ngx_http_request.c
---- nginx-1.2.3/src/http/ngx_http_request.c	2012-06-05 06:52:37.000000000 -0700
-+++ nginx-1.2.3-patched/src/http/ngx_http_request.c	2012-07-21 12:08:30.656376973 -0700
+diff -ur nginx-1.2.3/src/http/ngx_http_request.c nginx-1.2.3-patched/src/http/ngx_http_request.c
+--- nginx-1.2.3/src/http/ngx_http_request.c	2012-08-06 10:36:30.000000000 -0700
++++ nginx-1.2.3-patched/src/http/ngx_http_request.c	2012-08-30 11:37:42.395213999 -0700
 @@ -287,6 +287,8 @@
  
          r->pipeline = hc->pipeline;
@@ -111,11 +110,20 @@ diff '--exclude=*~' -ur nginx-1.2.3/src/http/ngx_http_request.c nginx-1.2.3-patc
          hc->request = r;
      }
  
-Only in nginx-1.2.3-patched/src/http: ngx_http_request.c.orig
-diff '--exclude=*~' -ur nginx-1.2.3/src/http/ngx_http_request.h nginx-1.2.3-patched/src/http/ngx_http_request.h
---- nginx-1.2.3/src/http/ngx_http_request.h	2012-02-28 06:54:23.000000000 -0800
-+++ nginx-1.2.3-patched/src/http/ngx_http_request.h	2012-07-21 12:08:30.657376978 -0700
-@@ -368,6 +368,9 @@
+diff -ur nginx-1.2.3/src/http/ngx_http_request.h nginx-1.2.3-patched/src/http/ngx_http_request.h
+--- nginx-1.2.3/src/http/ngx_http_request.h	2012-07-02 10:41:52.000000000 -0700
++++ nginx-1.2.3-patched/src/http/ngx_http_request.h	2012-08-30 11:39:37.085644830 -0700
+@@ -9,6 +9,9 @@
+ #define _NGX_HTTP_REQUEST_H_INCLUDED_
+ 
+ 
++#define HAVE_ALLOW_REQUEST_BODY_UPDATING_PATCH
++
++
+ #define NGX_HTTP_MAX_URI_CHANGES           10
+ #define NGX_HTTP_MAX_SUBREQUESTS           200
+ 
+@@ -375,6 +378,9 @@
      ngx_pool_t                       *pool;
      ngx_buf_t                        *header_in;
  

patches/nginx-1.2.3-channel-uninit-params.patch

@@ -0,0 +1,42 @@
+diff -urp nginx-1.2.3/src/os/unix/ngx_channel.c nginx-1.2.3-patched/src/os/unix/ngx_channel.c
+--- nginx-1.2.3/src/os/unix/ngx_channel.c	2012-01-18 07:07:43.000000000 -0800
++++ nginx-1.2.3-patched/src/os/unix/ngx_channel.c	2012-09-17 11:33:09.215394217 -0700
+@@ -31,6 +31,8 @@ ngx_write_channel(ngx_socket_t s, ngx_ch
+         msg.msg_controllen = 0;
+ 
+     } else {
++        ngx_memzero(&cmsg, sizeof(cmsg));
++
+         msg.msg_control = (caddr_t) &cmsg;
+         msg.msg_controllen = sizeof(cmsg);
+ 
+diff -urp nginx-1.2.3/src/os/unix/ngx_process_cycle.c nginx-1.2.3-patched/src/os/unix/ngx_process_cycle.c
+--- nginx-1.2.3/src/os/unix/ngx_process_cycle.c	2012-07-02 09:23:14.000000000 -0700
++++ nginx-1.2.3-patched/src/os/unix/ngx_process_cycle.c	2012-09-17 11:33:09.214394215 -0700
+@@ -356,6 +356,8 @@ ngx_start_worker_processes(ngx_cycle_t *
+ 
+     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_OPEN_CHANNEL;
+ 
+     for (i = 0; i < n; i++) {
+@@ -463,6 +465,8 @@ ngx_signal_worker_processes(ngx_cycle_t
+     ngx_err_t      err;
+     ngx_channel_t  ch;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+ #if (NGX_BROKEN_SCM_RIGHTS)
+ 
+     ch.command = 0;
+@@ -564,6 +568,8 @@ ngx_reap_children(ngx_cycle_t *cycle)
+     ngx_channel_t     ch;
+     ngx_core_conf_t  *ccf;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_CLOSE_CHANNEL;
+     ch.fd = -1;
+ 

patches/nginx-1.2.3-dtrace.patch

@@ -307,22 +307,25 @@ index c506d3d..cbbfbf1 100644
 +
 +DTRACE_FROM_SYSTEMTAP=YES
 diff --git a/auto/sources b/auto/sources
-index 374ad66..3c76cac 100644
+index 374ad66..82dbc88 100644
 --- a/auto/sources
 +++ b/auto/sources
-@@ -39,6 +39,11 @@ CORE_DEPS="src/core/nginx.h \
-            src/core/ngx_crypt.h"
- 
- 
+@@ -36,7 +36,13 @@ CORE_DEPS="src/core/nginx.h \
+            src/core/ngx_conf_file.h \
+            src/core/ngx_resolver.h \
+            src/core/ngx_open_file_cache.h \
+-           src/core/ngx_crypt.h"
++           src/core/ngx_crypt.h \
++           src/core/ngx_core_probe.h"
++
++
 +if [ $NGX_DTRACE = YES ]; then
 +    CORE_DEPS="$CORE_DEPS objs/ngx_dtrace_provider.h"
 +fi
-+
-+
+ 
+ 
  CORE_SRCS="src/core/nginx.c \
-            src/core/ngx_log.c \
-            src/core/ngx_palloc.c \
-@@ -82,14 +87,15 @@ OPENSSL_SRCS=src/event/ngx_event_openssl.c
+@@ -82,14 +88,15 @@ OPENSSL_SRCS=src/event/ngx_event_openssl.c
  
  EVENT_MODULES="ngx_events_module ngx_event_core_module"
  
@@ -340,7 +343,7 @@ index 374ad66..3c76cac 100644
  
  EVENT_SRCS="src/event/ngx_event.c \
              src/event/ngx_event_timer.c \
-@@ -291,7 +297,8 @@ HTTP_DEPS="src/http/ngx_http.h \
+@@ -291,7 +298,8 @@ HTTP_DEPS="src/http/ngx_http.h \
             src/http/ngx_http_script.h \
             src/http/ngx_http_upstream.h \
             src/http/ngx_http_upstream_round_robin.h \
@@ -350,7 +353,7 @@ index 374ad66..3c76cac 100644
  
  HTTP_SRCS="src/http/ngx_http.c \
             src/http/ngx_http_core_module.c \
-@@ -524,3 +531,8 @@ NGX_GOOGLE_PERFTOOLS_MODULE=ngx_google_perftools_module
+@@ -524,3 +532,8 @@ NGX_GOOGLE_PERFTOOLS_MODULE=ngx_google_perftools_module
  NGX_GOOGLE_PERFTOOLS_SRCS=src/misc/ngx_google_perftools_module.c
  
  NGX_CPP_TEST_SRCS=src/misc/ngx_cpp_test_module.cpp
@@ -397,14 +400,99 @@ index 45ea154..332c011 100755
  
  if test -z "$NGX_PLATFORM"; then
      echo "checking for OS"
+diff --git a/src/core/ngx_core_probe.h b/src/core/ngx_core_probe.h
+new file mode 100644
+index 0000000..91bf91e
+--- /dev/null
++++ b/src/core/ngx_core_probe.h
+@@ -0,0 +1,25 @@
++#ifndef _NGX_CORE_PROBE_H_INCLUDED_
++#define _NGX_CORE_PROBE_H_INCLUDED_
++
++
++#include <ngx_config.h>
++#include <ngx_core.h>
++#include <ngx_event.h>
++
++
++#if (NGX_DTRACE)
++
++#include <ngx_http.h>
++#include <ngx_dtrace_provider.h>
++
++#define ngx_core_probe_create_pool_done(pool, size)                             \
++    NGINX_CREATE_POOL_DONE(pool, size)
++
++#else /* !(NGX_DTRACE) */
++
++#define ngx_core_probe_create_pool_done(pool, size)
++
++#endif
++
++
++#endif /* _NGX_CORE_PROBE_H_INCLUDED_ */
+diff --git a/src/core/ngx_palloc.c b/src/core/ngx_palloc.c
+index efbc244..8d81aab 100644
+--- a/src/core/ngx_palloc.c
++++ b/src/core/ngx_palloc.c
+@@ -7,6 +7,7 @@
+ 
+ #include <ngx_config.h>
+ #include <ngx_core.h>
++#include <ngx_core_probe.h>
+ 
+ 
+ static void *ngx_palloc_block(ngx_pool_t *pool, size_t size);
+@@ -37,6 +38,8 @@ ngx_create_pool(size_t size, ngx_log_t *log)
+     p->cleanup = NULL;
+     p->log = log;
+ 
++    ngx_core_probe_create_pool_done(p, size);
++
+     return p;
+ }
+ 
 diff --git a/src/dtrace/nginx.stp b/src/dtrace/nginx.stp
 new file mode 100644
-index 0000000..3dde1be
+index 0000000..5bae185
 --- /dev/null
 +++ b/src/dtrace/nginx.stp
-@@ -0,0 +1,199 @@
+@@ -0,0 +1,269 @@
 +/* tapset for nginx */
 +
++
++function ngx_indent(n, delta)
++{
++    s = ""
++    for (i = 0; i < n; i++) {
++        s .= delta
++    }
++
++    return s
++}
++
++
++function ngx_http_subreq_depth(r)
++{
++    depth = 0
++
++    for (pr = @cast(r, "ngx_http_request_t", "NGX_SBIN_PATH")->parent;
++         pr != 0;
++         pr = @cast(pr, "ngx_http_request_t", "NGX_SBIN_PATH")->parent)
++    {
++        depth++
++    }
++
++    return depth
++}
++
++
++function ngx_http_req_parent(r)
++{
++    return @cast(r, "ngx_http_request_s", "NGX_SBIN_PATH")->parent
++}
++
++
 +/* retrieve the request uri string from the ngx_http_request_t pointer */
 +function ngx_http_req_uri(r)
 +{
@@ -500,6 +588,24 @@ index 0000000..3dde1be
 +}
 +
 +
++function ngx_buf_last_buf(b)
++{
++    return @cast(b, "ngx_buf_t", "/home/agentzh/git/lua-nginx-module/work/nginx/sbin/nginx")->last_buf
++}
++
++
++function ngx_buf_sync(b)
++{
++    return @cast(b, "ngx_buf_t", "/home/agentzh/git/lua-nginx-module/work/nginx/sbin/nginx")->sync
++}
++
++
++function ngx_buf_flush(b)
++{
++    return @cast(b, "ngx_buf_t", "/home/agentzh/git/lua-nginx-module/work/nginx/sbin/nginx")->flush
++}
++
++
 +function ngx_buf_size(b)
 +{
 +    if (ngx_buf_in_memory(b)) {
@@ -532,7 +638,26 @@ index 0000000..3dde1be
 +    cl = input
 +    while (cl) {
 +        buf = ngx_chain_buf(cl)
-+        out .= sprintf("[%s]", text_str(ngx_buf_data(buf)))
++
++        if (ngx_buf_in_memory(buf)) {
++            out .= sprintf("[%s]", text_str(ngx_buf_data(buf)))
++
++        } else {
++            out .= "\"\""
++        }
++
++        if (ngx_buf_last_buf(buf)) {
++            out .= "<eof>"
++        }
++
++        if (ngx_buf_sync(buf)) {
++            out .= "<sync>"
++        }
++
++        if (ngx_buf_flush(buf)) {
++            out .= "<flush>"
++        }
++
 +        cl = ngx_chain_next(cl)
 +        if (cl) {
 +            out .= sprintf(" ")
@@ -604,10 +729,10 @@ index 0000000..3dde1be
 +
 diff --git a/src/dtrace/nginx_provider.d b/src/dtrace/nginx_provider.d
 new file mode 100644
-index 0000000..e583a52
+index 0000000..147ca12
 --- /dev/null
 +++ b/src/dtrace/nginx_provider.d
-@@ -0,0 +1,39 @@
+@@ -0,0 +1,41 @@
 +typedef struct { int dummy; } ngx_http_request_t;
 +typedef struct { int dummy; } ngx_str_t;
 +typedef int64_t ngx_int_t;
@@ -617,6 +742,7 @@ index 0000000..e583a52
 +typedef struct { int dummy; } ngx_http_module_t;
 +typedef struct { int dummy; } ngx_table_elt_t;
 +typedef struct { int dummy; } ngx_event_t;
++typedef struct { int dummy; } ngx_pool_t;
 +typedef char unsigned u_char;
 +
 +
@@ -638,6 +764,7 @@ index 0000000..e583a52
 +    probe timer__add(ngx_event_t *ev, ngx_msec_t timer);
 +    probe timer__del(ngx_event_t *ev);
 +    probe timer__expire(ngx_event_t *ev);
++    probe create__pool__done(ngx_pool_t *pool, size_t size);
 +};
 +
 +

patches/nginx-1.2.3-nonbuffered-upstream-truncation.patch

@@ -0,0 +1,63 @@
+--- nginx-1.2.3/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.2.3-patched/src/http/ngx_http_upstream.c	2012-09-09 21:58:04.727761891 -0700
+@@ -2383,7 +2383,7 @@
+ 
+     if (c->read->timedout) {
+         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
+-        ngx_http_upstream_finalize_request(r, u, 0);
++        ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
+         return;
+     }
+ 
+@@ -2430,13 +2430,17 @@
+             if (u->busy_bufs == NULL) {
+ 
+                 if (u->length == 0
+-                    || upstream->read->eof
+-                    || upstream->read->error)
++                    || (upstream->read->eof && u->headers_in.content_length_n == -1))
+                 {
+                     ngx_http_upstream_finalize_request(r, u, 0);
+                     return;
+                 }
+ 
++                if (upstream->read->eof || upstream->read->error) {
++                    ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++                    return;
++                }
++
+                 b->pos = b->start;
+                 b->last = b->start;
+             }
+@@ -2710,7 +2714,16 @@
+ #if 0
+             ngx_http_busy_unlock(u->conf->busy_lock, &u->busy_lock);
+ #endif
+-            ngx_http_upstream_finalize_request(r, u, 0);
++
++            if (p->upstream_done
++                || (p->upstream_eof && u->headers_in.content_length_n == -1))
++            {
++                ngx_http_upstream_finalize_request(r, u, 0);
++
++            } else {
++                ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++            }
++
+             return;
+         }
+     }
+@@ -3073,6 +3086,13 @@
+         && rc != NGX_HTTP_REQUEST_TIME_OUT
+         && (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
+     {
++        if (rc == NGX_ERROR) {
++            r->headers_out.status = NGX_HTTP_INTERNAL_SERVER_ERROR;
++
++        } else {
++            r->headers_out.status = rc;
++        }
++
+         rc = 0;
+     }
+ 

patches/nginx-1.2.4-allow_request_body_updating.patch

@@ -0,0 +1,136 @@
+diff -ur nginx-1.2.4/src/http/ngx_http_core_module.c nginx-1.2.4-patched/src/http/ngx_http_core_module.c
+--- nginx-1.2.4/src/http/ngx_http_core_module.c	2012-08-06 10:31:32.000000000 -0700
++++ nginx-1.2.4-patched/src/http/ngx_http_core_module.c	2012-08-30 11:37:42.388213974 -0700
+@@ -2420,6 +2420,8 @@
+ 
+     sr->request_body = r->request_body;
+ 
++    sr->content_length_n = -1;
++
+     sr->method = NGX_HTTP_GET;
+     sr->http_version = r->http_version;
+ 
+diff -ur nginx-1.2.4/src/http/ngx_http_request_body.c nginx-1.2.4-patched/src/http/ngx_http_request_body.c
+--- nginx-1.2.4/src/http/ngx_http_request_body.c	2012-04-12 12:35:41.000000000 -0700
++++ nginx-1.2.4-patched/src/http/ngx_http_request_body.c	2012-08-30 11:37:42.388213974 -0700
+@@ -39,7 +39,7 @@
+ 
+     r->main->count++;
+ 
+-    if (r->request_body || r->discard_body) {
++    if (r->request_body || r->discard_body || r->content_length_n == 0) {
+         post_handler(r);
+         return NGX_OK;
+     }
+@@ -441,7 +441,7 @@
+     ssize_t       size;
+     ngx_event_t  *rev;
+ 
+-    if (r != r->main || r->discard_body) {
++    if (r != r->main || r->discard_body || r->content_length_n == 0) {
+         return NGX_OK;
+     }
+ 
+@@ -457,20 +457,22 @@
+         ngx_del_timer(rev);
+     }
+ 
+-    if (r->headers_in.content_length_n <= 0 || r->request_body) {
++    r->content_length_n = r->headers_in.content_length_n;
++
++    if (r->content_length_n <= 0 || r->request_body) {
+         return NGX_OK;
+     }
+ 
+     size = r->header_in->last - r->header_in->pos;
+ 
+     if (size) {
+-        if (r->headers_in.content_length_n > size) {
++        if (r->content_length_n > size) {
+             r->header_in->pos += size;
+-            r->headers_in.content_length_n -= size;
++            r->content_length_n -= size;
+ 
+         } else {
+-            r->header_in->pos += (size_t) r->headers_in.content_length_n;
+-            r->headers_in.content_length_n = 0;
++            r->header_in->pos += (size_t) r->content_length_n;
++            r->content_length_n = 0;
+             return NGX_OK;
+         }
+     }
+@@ -569,7 +571,7 @@
+                    "http read discarded body");
+ 
+     for ( ;; ) {
+-        if (r->headers_in.content_length_n == 0) {
++        if (r->content_length_n == 0) {
+             r->read_event_handler = ngx_http_block_reading;
+             return NGX_OK;
+         }
+@@ -578,9 +580,9 @@
+             return NGX_AGAIN;
+         }
+ 
+-        size = (r->headers_in.content_length_n > NGX_HTTP_DISCARD_BUFFER_SIZE) ?
++        size = (r->content_length_n > NGX_HTTP_DISCARD_BUFFER_SIZE) ?
+                    NGX_HTTP_DISCARD_BUFFER_SIZE:
+-                   (size_t) r->headers_in.content_length_n;
++                   (size_t) r->content_length_n;
+ 
+         n = r->connection->recv(r->connection, buffer, size);
+ 
+@@ -597,7 +599,7 @@
+             return NGX_OK;
+         }
+ 
+-        r->headers_in.content_length_n -= n;
++        r->content_length_n -= n;
+     }
+ }
+ 
+diff -ur nginx-1.2.4/src/http/ngx_http_request.c nginx-1.2.4-patched/src/http/ngx_http_request.c
+--- nginx-1.2.4/src/http/ngx_http_request.c	2012-08-06 10:36:30.000000000 -0700
++++ nginx-1.2.4-patched/src/http/ngx_http_request.c	2012-08-30 11:37:42.395213999 -0700
+@@ -287,6 +287,8 @@
+ 
+         r->pipeline = hc->pipeline;
+ 
++        r->content_length_n = -1;
++
+         if (hc->nbusy) {
+             r->header_in = hc->busy[0];
+         }
+@@ -298,6 +300,8 @@
+             return;
+         }
+ 
++        r->content_length_n = -1;
++
+         hc->request = r;
+     }
+ 
+diff -ur nginx-1.2.4/src/http/ngx_http_request.h nginx-1.2.4-patched/src/http/ngx_http_request.h
+--- nginx-1.2.4/src/http/ngx_http_request.h	2012-07-02 10:41:52.000000000 -0700
++++ nginx-1.2.4-patched/src/http/ngx_http_request.h	2012-08-30 11:39:37.085644830 -0700
+@@ -9,6 +9,9 @@
+ #define _NGX_HTTP_REQUEST_H_INCLUDED_
+ 
+ 
++#define HAVE_ALLOW_REQUEST_BODY_UPDATING_PATCH
++
++
+ #define NGX_HTTP_MAX_URI_CHANGES           10
+ #define NGX_HTTP_MAX_SUBREQUESTS           200
+ 
+@@ -375,6 +378,9 @@
+     ngx_pool_t                       *pool;
+     ngx_buf_t                        *header_in;
+ 
++    off_t                             content_length_n;
++                                          /* for discarding request body */
++
+     ngx_http_headers_in_t             headers_in;
+     ngx_http_headers_out_t            headers_out;
+ 
+Only in nginx-1.2.4-patched/src/http: ngx_http_request.h.orig

patches/nginx-1.2.4-channel-uninit-params.patch

@@ -0,0 +1,42 @@
+diff -urp nginx-1.2.4/src/os/unix/ngx_channel.c nginx-1.2.4-patched/src/os/unix/ngx_channel.c
+--- nginx-1.2.4/src/os/unix/ngx_channel.c	2012-01-18 07:07:43.000000000 -0800
++++ nginx-1.2.4-patched/src/os/unix/ngx_channel.c	2012-09-17 11:33:09.215394217 -0700
+@@ -31,6 +31,8 @@ ngx_write_channel(ngx_socket_t s, ngx_ch
+         msg.msg_controllen = 0;
+ 
+     } else {
++        ngx_memzero(&cmsg, sizeof(cmsg));
++
+         msg.msg_control = (caddr_t) &cmsg;
+         msg.msg_controllen = sizeof(cmsg);
+ 
+diff -urp nginx-1.2.4/src/os/unix/ngx_process_cycle.c nginx-1.2.4-patched/src/os/unix/ngx_process_cycle.c
+--- nginx-1.2.4/src/os/unix/ngx_process_cycle.c	2012-07-02 09:23:14.000000000 -0700
++++ nginx-1.2.4-patched/src/os/unix/ngx_process_cycle.c	2012-09-17 11:33:09.214394215 -0700
+@@ -356,6 +356,8 @@ ngx_start_worker_processes(ngx_cycle_t *
+ 
+     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_OPEN_CHANNEL;
+ 
+     for (i = 0; i < n; i++) {
+@@ -463,6 +465,8 @@ ngx_signal_worker_processes(ngx_cycle_t
+     ngx_err_t      err;
+     ngx_channel_t  ch;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+ #if (NGX_BROKEN_SCM_RIGHTS)
+ 
+     ch.command = 0;
+@@ -564,6 +568,8 @@ ngx_reap_children(ngx_cycle_t *cycle)
+     ngx_channel_t     ch;
+     ngx_core_conf_t  *ccf;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_CLOSE_CHANNEL;
+     ch.fd = -1;
+ 

patches/nginx-1.2.4-location_if_inherits_proxy.patch

@@ -0,0 +1,15 @@
+--- nginx-1.2.4/src/http/modules/ngx_http_proxy_module.c	2012-04-23 18:40:01.000000000 +0800
++++ nginx-1.2.4-patched/src/http/modules/ngx_http_proxy_module.c	2012-06-24 12:48:57.289834450 +0800
+@@ -3023,8 +3023,10 @@
+ 
+     if (conf->upstream.upstream || conf->proxy_lengths) {
+         clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
+-        if (clcf->handler == NULL && clcf->lmt_excpt) {
+-            clcf->handler = ngx_http_proxy_handler;
++        if (clcf->handler == NULL) {
++            if (clcf->lmt_excpt) {
++                clcf->handler = ngx_http_proxy_handler;
++            }
+             conf->location = prev->location;
+         }
+     }

patches/nginx-1.2.4-log_escape_non_ascii.patch

@@ -0,0 +1,115 @@
+--- nginx-1.2.4/src/http/modules/ngx_http_log_module.c	2011-11-01 21:24:50.000000000 +0800
++++ nginx-1.2.4-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.2.4-no_Werror.patch

@@ -0,0 +1,24 @@
+diff -ur nginx-1.2.4/auto/cc/gcc nginx-1.2.4-patched/auto/cc/gcc
+--- nginx-1.2.4/auto/cc/gcc	2011-06-27 19:53:00.205737804 +0800
++++ nginx-1.2.4-patched/auto/cc/gcc	2011-06-27 19:53:13.837741087 +0800
+@@ -169,7 +169,7 @@
+ 
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"
+diff -ur nginx-1.2.4/auto/cc/icc nginx-1.2.4-patched/auto/cc/icc
+--- nginx-1.2.4/auto/cc/icc	2011-06-27 19:52:56.370157068 +0800
++++ nginx-1.2.4-patched/auto/cc/icc	2011-06-27 19:53:19.508916811 +0800
+@@ -139,7 +139,7 @@
+ esac
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"

patches/nginx-1.2.4-no_error_pages.patch

@@ -0,0 +1,90 @@
+--- nginx-1.2.4/src/http/ngx_http_core_module.c	2010-12-14 18:38:42.000000000 +0800
++++ nginx-1.2.4-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.2.4-no_pool.patch

@@ -0,0 +1,609 @@
+diff -ur nginx-1.2.4/src/core/nginx.h nginx-1.2.4-patched/src/core/nginx.h
+--- nginx-1.2.4/src/core/nginx.h	2011-08-29 17:30:22.000000000 +0800
++++ nginx-1.2.4-patched/src/core/nginx.h	2011-09-13 12:11:03.135622101 +0800
+@@ -10,7 +10,7 @@
+ 
+ 
+ #define nginx_version      1002004
+ #define NGINX_VERSION      "1.2.4"
+-#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown (no pool)"
+ 
+ #define NGINX_VAR          "NGINX"
+diff -urx '*~' -x '*.swp' nginx-1.2.4/src/core/ngx_array.c nginx-1.2.4-patched/src/core/ngx_array.c
+--- nginx-1.2.4/src/core/ngx_array.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.4-patched/src/core/ngx_array.c	2012-06-20 23:10:36.870722387 +0800
+@@ -28,6 +28,7 @@
+     a->size = size;
+     a->nalloc = n;
+     a->pool = p;
++    a->old_elts = NULL;
+ 
+     return a;
+ }
+@@ -36,26 +37,30 @@
+ 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) {
+ 
+@@ -65,29 +70,27 @@
+ 
+         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++;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            new = ngx_palloc(p, 2 * size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, size);
+-            a->elts = new;
+-            a->nalloc *= 2;
++        /* allocate a new array */
++
++        new = ngx_palloc(p, 2 * size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, size);
++
++        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;
+@@ -101,11 +104,10 @@
+ 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) {
+ 
+@@ -113,31 +115,27 @@
+ 
+         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
+-             */
+-
+-            p->d.last += size;
+-            a->nalloc += n;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
+-
+-            new = ngx_palloc(p, nalloc * a->size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, a->nelts * a->size);
+-            a->elts = new;
+-            a->nalloc = nalloc;
++        nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
++
++        new = ngx_palloc(p, nalloc * a->size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, a->nelts * a->size);
++
++        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 = nalloc;
+     }
+ 
+     elt = (u_char *) a->elts + a->size * a->nelts;
+diff -urx '*~' -x '*.swp' nginx-1.2.4/src/core/ngx_array.h nginx-1.2.4-patched/src/core/ngx_array.h
+--- nginx-1.2.4/src/core/ngx_array.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.4-patched/src/core/ngx_array.h	2012-06-20 23:25:38.800624960 +0800
+@@ -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;
++};
++
++
+ struct ngx_array_s {
+     void        *elts;
+     ngx_uint_t   nelts;
+     size_t       size;
+     ngx_uint_t   nalloc;
+     ngx_pool_t  *pool;
++
++    ngx_array_link_t *old_elts;
+ };
+ 
+ 
+@@ -40,6 +51,7 @@
+     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 -urx '*~' -x '*.swp' nginx-1.2.4/src/core/ngx_palloc.c nginx-1.2.4-patched/src/core/ngx_palloc.c
+--- nginx-1.2.4/src/core/ngx_palloc.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.4-patched/src/core/ngx_palloc.c	2012-06-20 22:56:30.148073066 +0800
+@@ -9,32 +9,23 @@
+ #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);
+-
+-
+ 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 +35,7 @@
+ 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 +46,9 @@
+         }
+     }
+ 
+-    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 +58,9 @@
+      * 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,172 +69,82 @@
+ 
+ #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;
+ 
+-void
+-ngx_reset_pool(ngx_pool_t *pool)
+-{
+-    ngx_pool_t        *p;
+-    ngx_pool_large_t  *l;
+-
+-    for (l = pool->large; l; l = l->next) {
+-        if (l->alloc) {
+-            ngx_free(l->alloc);
+-        }
+-    }
+-
+-    pool->large = NULL;
+-
+-    for (p = pool; p; p = p->d.next) {
+-        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
+-    }
++    ngx_free(pool);
+ }
+ 
+ 
+-void *
+-ngx_palloc(ngx_pool_t *pool, size_t size)
++void
++ngx_reset_pool(ngx_pool_t *pool)
+ {
+-    u_char      *m;
+-    ngx_pool_t  *p;
+-
+-    if (size <= pool->max) {
++    ngx_pool_data_t     *d, *n;
++    ngx_pool_data_t     *saved = NULL;
+ 
+-        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;
++    if (pool->d) {
++        for (d = pool->d, n = d->next; ; d = n, n = n->next) {
++            if (d->alloc == pool->log) {
++                saved = d;
++                continue;
+             }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
+-    }
+-
+-    return ngx_palloc_large(pool, size);
+-}
+-
++            ngx_free(d->alloc);
++            ngx_free(d);
+ 
+-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;
++            if (n == NULL) {
++                break;
+             }
++        }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
++        pool->d = saved;
+     }
+-
+-    return ngx_palloc_large(pool, size);
+ }
+ 
+ 
+-static void *
+-ngx_palloc_block(ngx_pool_t *pool, size_t size)
++void *
++ngx_malloc(ngx_pool_t *pool, size_t size)
+ {
+-    u_char      *m;
+-    size_t       psize;
+-    ngx_pool_t  *p, *new, *current;
++    ngx_pool_data_t     *d;
++    void                *p;
+ 
+-    psize = (size_t) (pool->d.end - (u_char *) pool);
+-
+-    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
+-    if (m == NULL) {
++    p = ngx_alloc(size, pool->log);
++    if (p == 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;
+-
+-    current = pool->current;
+-
+-    for (p = current; p->d.next; p = p->d.next) {
+-        if (p->d.failed++ > 4) {
+-            current = p->d.next;
+-        }
++    d = ngx_alloc(sizeof(ngx_pool_data_t), pool->log);
++    if (d == NULL){
++        ngx_free(p);
++        return NULL;
+     }
+ 
+-    p->d.next = new;
+-
+-    pool->current = current ? current : new;
+-
+-    return m;
++    d->alloc = p;
++    d->next = pool->d;
++    pool->d = d;
++    return p;
+ }
+ 
+ 
+-static void *
+-ngx_palloc_large(ngx_pool_t *pool, size_t size)
++void *
++ngx_palloc(ngx_pool_t *pool, size_t size)
+ {
+-    void              *p;
+-    ngx_uint_t         n;
+-    ngx_pool_large_t  *large;
+-
+-    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) {
+-        ngx_free(p);
+-        return NULL;
+-    }
++    return ngx_malloc(pool, size);
++}
+ 
+-    large->alloc = p;
+-    large->next = pool->large;
+-    pool->large = large;
+ 
+-    return p;
++void *
++ngx_pnalloc(ngx_pool_t *pool, size_t size)
++{
++    return ngx_malloc(pool, size);
+ }
+ 
+ 
+@@ -256,38 +152,48 @@
+ 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 -urx '*~' -x '*.swp' nginx-1.2.4/src/core/ngx_palloc.h nginx-1.2.4-patched/src/core/ngx_palloc.h
+--- nginx-1.2.4/src/core/ngx_palloc.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.4-patched/src/core/ngx_palloc.h	2012-06-21 10:35:47.463405863 +0800
+@@ -38,28 +38,21 @@
+ };
+ 
+ 
+-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.2.4-nonbuffered-upstream-truncation.patch

@@ -0,0 +1,63 @@
+--- nginx-1.2.4/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.2.4-patched/src/http/ngx_http_upstream.c	2012-09-09 21:58:04.727761891 -0700
+@@ -2383,7 +2383,7 @@
+ 
+     if (c->read->timedout) {
+         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
+-        ngx_http_upstream_finalize_request(r, u, 0);
++        ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
+         return;
+     }
+ 
+@@ -2430,13 +2430,17 @@
+             if (u->busy_bufs == NULL) {
+ 
+                 if (u->length == 0
+-                    || upstream->read->eof
+-                    || upstream->read->error)
++                    || (upstream->read->eof && u->headers_in.content_length_n == -1))
+                 {
+                     ngx_http_upstream_finalize_request(r, u, 0);
+                     return;
+                 }
+ 
++                if (upstream->read->eof || upstream->read->error) {
++                    ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++                    return;
++                }
++
+                 b->pos = b->start;
+                 b->last = b->start;
+             }
+@@ -2710,7 +2714,16 @@
+ #if 0
+             ngx_http_busy_unlock(u->conf->busy_lock, &u->busy_lock);
+ #endif
+-            ngx_http_upstream_finalize_request(r, u, 0);
++
++            if (p->upstream_done
++                || (p->upstream_eof && u->headers_in.content_length_n == -1))
++            {
++                ngx_http_upstream_finalize_request(r, u, 0);
++
++            } else {
++                ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++            }
++
+             return;
+         }
+     }
+@@ -3073,6 +3086,13 @@
+         && rc != NGX_HTTP_REQUEST_TIME_OUT
+         && (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
+     {
++        if (rc == NGX_ERROR) {
++            r->headers_out.status = NGX_HTTP_INTERNAL_SERVER_ERROR;
++
++        } else {
++            r->headers_out.status = rc;
++        }
++
+         rc = 0;
+     }
+ 

patches/nginx-1.2.4-server_header.patch

@@ -0,0 +1,26 @@
+diff -ur lz-nginx-1.2.4/nginx-1.2.4/src/core/nginx.h lz-nginx-1.2.4-patched/nginx-1.2.4/src/core/nginx.h
+--- lz-nginx-1.2.4/nginx-1.2.4/src/core/nginx.h	2010-02-12 17:31:01.000000000 +0800
++++ lz-nginx-1.2.4-patched/nginx-1.2.4/src/core/nginx.h	2010-03-30 10:52:13.240702627 +0800
+@@ -10,7 +10,7 @@
+ 
+ #define nginx_version         1002004
+ #define NGINX_VERSION      "1.2.4"
+-#define NGINX_VER          "nginx/" NGINX_VERSION
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
+ 
+ #define NGINX_VAR          "NGINX"
+ #define NGX_OLDPID_EXT     ".oldbin"
+Only in lz-nginx-1.2.4-patched/nginx-1.2.4/src/core: nginx.h.orig
+Only in lz-nginx-1.2.4-patched/nginx-1.2.4/src/core: nginx.h.rej
+diff -ur lz-nginx-1.2.4/nginx-1.2.4/src/http/ngx_http_header_filter_module.c lz-nginx-1.2.4-patched/nginx-1.2.4/src/http/ngx_http_header_filter_module.c
+--- lz-nginx-1.2.4/nginx-1.2.4/src/http/ngx_http_header_filter_module.c	2010-03-03 23:14:04.000000000 +0800
++++ lz-nginx-1.2.4-patched/nginx-1.2.4/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: ngx_openresty" CRLF;
+ static char ngx_http_server_full_string[] = "Server: " NGINX_VER CRLF;
+ 
+ 

patches/nginx-1.2.4-slab_alloc_no_memory_as_info.patch

@@ -0,0 +1,11 @@
+--- nginx-1.2.4/src/core/ngx_slab.c	2012-09-24 11:34:04.000000000 -0700
++++ nginx-1.2.4-patched/src/core/ngx_slab.c	2012-12-05 20:47:07.296694952 -0800
+@@ -657,7 +657,7 @@ ngx_slab_alloc_pages(ngx_slab_pool_t *po
+         }
+     }
+ 
+-    ngx_slab_error(pool, NGX_LOG_CRIT, "ngx_slab_alloc() failed: no memory");
++    ngx_slab_error(pool, NGX_LOG_INFO, "ngx_slab_alloc() failed: no memory");
+ 
+     return NULL;
+ }

patches/nginx-1.2.4-upstream_pipelining.patch

@@ -0,0 +1,40 @@
+diff -rudp nginx-1.2.4/src/http/ngx_http_upstream.c nginx-1.2.4-patched/src/http/ngx_http_upstream.c
+--- nginx-1.2.4/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.2.4-patched/src/http/ngx_http_upstream.c	2012-12-05 14:46:41.741173058 -0800
+@@ -1216,6 +1216,7 @@ ngx_http_upstream_connect(ngx_http_reque
+     }
+ 
+     u->request_sent = 0;
++    u->request_all_sent = 0;
+ 
+     if (rc == NGX_AGAIN) {
+         ngx_add_timer(c->write, u->conf->connect_timeout);
+@@ -1418,6 +1419,8 @@ ngx_http_upstream_send_request(ngx_http_
+ 
+     /* rc == NGX_OK */
+ 
++    u->request_all_sent = 1;
++
+     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
+         if (ngx_tcp_push(c->fd) == NGX_ERROR) {
+             ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
+@@ -1484,7 +1487,7 @@ ngx_http_upstream_send_request_handler(n
+ 
+ #endif
+ 
+-    if (u->header_sent) {
++    if (u->request_all_sent) {
+         u->write_event_handler = ngx_http_upstream_dummy_handler;
+ 
+         (void) ngx_handle_write_event(c->write, 0);
+diff -rudp nginx-1.2.4/src/http/ngx_http_upstream.h nginx-1.2.4-patched/src/http/ngx_http_upstream.h
+--- nginx-1.2.4/src/http/ngx_http_upstream.h	2012-02-13 03:01:58.000000000 -0800
++++ nginx-1.2.4-patched/src/http/ngx_http_upstream.h	2012-12-05 14:41:09.763514741 -0800
+@@ -324,6 +324,7 @@ struct ngx_http_upstream_s {
+     unsigned                         keepalive:1;
+ 
+     unsigned                         request_sent:1;
++    unsigned                         request_all_sent:1;
+     unsigned                         header_sent:1;
+ };
+ 

patches/nginx-1.2.4-upstream_test_connect_kqueue.patch

@@ -0,0 +1,26 @@
+--- nginx-1.2.4/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.2.4-patched/src/http/ngx_http_upstream.c	2012-11-05 21:17:38.000000000 -0800
+@@ -1808,10 +1808,22 @@ ngx_http_upstream_test_connect(ngx_conne
+ 
+ #if (NGX_HAVE_KQUEUE)
+ 
++    ngx_event_t *ev;
++
+     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT)  {
+         if (c->write->pending_eof) {
++            ev = c->write;
++
++        } else if (c->read->pending_eof) {
++            ev = c->read;
++
++        } else {
++            ev = NULL;
++        }
++
++        if (ev) {
+             c->log->action = "connecting to upstream";
+-            (void) ngx_connection_error(c, c->write->kq_errno,
++            (void) ngx_connection_error(c, ev->kq_errno,
+                                     "kevent() reported that connect() failed");
+             return NGX_ERROR;
+         }

patches/nginx-1.2.5-allow_request_body_updating.patch

@@ -0,0 +1,136 @@
+diff -ur nginx-1.2.5/src/http/ngx_http_core_module.c nginx-1.2.5-patched/src/http/ngx_http_core_module.c
+--- nginx-1.2.5/src/http/ngx_http_core_module.c	2012-08-06 10:31:32.000000000 -0700
++++ nginx-1.2.5-patched/src/http/ngx_http_core_module.c	2012-08-30 11:37:42.388213974 -0700
+@@ -2420,6 +2420,8 @@
+ 
+     sr->request_body = r->request_body;
+ 
++    sr->content_length_n = -1;
++
+     sr->method = NGX_HTTP_GET;
+     sr->http_version = r->http_version;
+ 
+diff -ur nginx-1.2.5/src/http/ngx_http_request_body.c nginx-1.2.5-patched/src/http/ngx_http_request_body.c
+--- nginx-1.2.5/src/http/ngx_http_request_body.c	2012-04-12 12:35:41.000000000 -0700
++++ nginx-1.2.5-patched/src/http/ngx_http_request_body.c	2012-08-30 11:37:42.388213974 -0700
+@@ -39,7 +39,7 @@
+ 
+     r->main->count++;
+ 
+-    if (r->request_body || r->discard_body) {
++    if (r->request_body || r->discard_body || r->content_length_n == 0) {
+         post_handler(r);
+         return NGX_OK;
+     }
+@@ -441,7 +441,7 @@
+     ssize_t       size;
+     ngx_event_t  *rev;
+ 
+-    if (r != r->main || r->discard_body) {
++    if (r != r->main || r->discard_body || r->content_length_n == 0) {
+         return NGX_OK;
+     }
+ 
+@@ -457,20 +457,22 @@
+         ngx_del_timer(rev);
+     }
+ 
+-    if (r->headers_in.content_length_n <= 0 || r->request_body) {
++    r->content_length_n = r->headers_in.content_length_n;
++
++    if (r->content_length_n <= 0 || r->request_body) {
+         return NGX_OK;
+     }
+ 
+     size = r->header_in->last - r->header_in->pos;
+ 
+     if (size) {
+-        if (r->headers_in.content_length_n > size) {
++        if (r->content_length_n > size) {
+             r->header_in->pos += size;
+-            r->headers_in.content_length_n -= size;
++            r->content_length_n -= size;
+ 
+         } else {
+-            r->header_in->pos += (size_t) r->headers_in.content_length_n;
+-            r->headers_in.content_length_n = 0;
++            r->header_in->pos += (size_t) r->content_length_n;
++            r->content_length_n = 0;
+             return NGX_OK;
+         }
+     }
+@@ -569,7 +571,7 @@
+                    "http read discarded body");
+ 
+     for ( ;; ) {
+-        if (r->headers_in.content_length_n == 0) {
++        if (r->content_length_n == 0) {
+             r->read_event_handler = ngx_http_block_reading;
+             return NGX_OK;
+         }
+@@ -578,9 +580,9 @@
+             return NGX_AGAIN;
+         }
+ 
+-        size = (r->headers_in.content_length_n > NGX_HTTP_DISCARD_BUFFER_SIZE) ?
++        size = (r->content_length_n > NGX_HTTP_DISCARD_BUFFER_SIZE) ?
+                    NGX_HTTP_DISCARD_BUFFER_SIZE:
+-                   (size_t) r->headers_in.content_length_n;
++                   (size_t) r->content_length_n;
+ 
+         n = r->connection->recv(r->connection, buffer, size);
+ 
+@@ -597,7 +599,7 @@
+             return NGX_OK;
+         }
+ 
+-        r->headers_in.content_length_n -= n;
++        r->content_length_n -= n;
+     }
+ }
+ 
+diff -ur nginx-1.2.5/src/http/ngx_http_request.c nginx-1.2.5-patched/src/http/ngx_http_request.c
+--- nginx-1.2.5/src/http/ngx_http_request.c	2012-08-06 10:36:30.000000000 -0700
++++ nginx-1.2.5-patched/src/http/ngx_http_request.c	2012-08-30 11:37:42.395213999 -0700
+@@ -287,6 +287,8 @@
+ 
+         r->pipeline = hc->pipeline;
+ 
++        r->content_length_n = -1;
++
+         if (hc->nbusy) {
+             r->header_in = hc->busy[0];
+         }
+@@ -298,6 +300,8 @@
+             return;
+         }
+ 
++        r->content_length_n = -1;
++
+         hc->request = r;
+     }
+ 
+diff -ur nginx-1.2.5/src/http/ngx_http_request.h nginx-1.2.5-patched/src/http/ngx_http_request.h
+--- nginx-1.2.5/src/http/ngx_http_request.h	2012-07-02 10:41:52.000000000 -0700
++++ nginx-1.2.5-patched/src/http/ngx_http_request.h	2012-08-30 11:39:37.085644830 -0700
+@@ -9,6 +9,9 @@
+ #define _NGX_HTTP_REQUEST_H_INCLUDED_
+ 
+ 
++#define HAVE_ALLOW_REQUEST_BODY_UPDATING_PATCH
++
++
+ #define NGX_HTTP_MAX_URI_CHANGES           10
+ #define NGX_HTTP_MAX_SUBREQUESTS           200
+ 
+@@ -375,6 +378,9 @@
+     ngx_pool_t                       *pool;
+     ngx_buf_t                        *header_in;
+ 
++    off_t                             content_length_n;
++                                          /* for discarding request body */
++
+     ngx_http_headers_in_t             headers_in;
+     ngx_http_headers_out_t            headers_out;
+ 
+Only in nginx-1.2.5-patched/src/http: ngx_http_request.h.orig

patches/nginx-1.2.5-channel-uninit-params.patch

@@ -0,0 +1,42 @@
+diff -urp nginx-1.2.5/src/os/unix/ngx_channel.c nginx-1.2.5-patched/src/os/unix/ngx_channel.c
+--- nginx-1.2.5/src/os/unix/ngx_channel.c	2012-01-18 07:07:43.000000000 -0800
++++ nginx-1.2.5-patched/src/os/unix/ngx_channel.c	2012-09-17 11:33:09.215394217 -0700
+@@ -31,6 +31,8 @@ ngx_write_channel(ngx_socket_t s, ngx_ch
+         msg.msg_controllen = 0;
+ 
+     } else {
++        ngx_memzero(&cmsg, sizeof(cmsg));
++
+         msg.msg_control = (caddr_t) &cmsg;
+         msg.msg_controllen = sizeof(cmsg);
+ 
+diff -urp nginx-1.2.5/src/os/unix/ngx_process_cycle.c nginx-1.2.5-patched/src/os/unix/ngx_process_cycle.c
+--- nginx-1.2.5/src/os/unix/ngx_process_cycle.c	2012-07-02 09:23:14.000000000 -0700
++++ nginx-1.2.5-patched/src/os/unix/ngx_process_cycle.c	2012-09-17 11:33:09.214394215 -0700
+@@ -356,6 +356,8 @@ ngx_start_worker_processes(ngx_cycle_t *
+ 
+     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_OPEN_CHANNEL;
+ 
+     for (i = 0; i < n; i++) {
+@@ -463,6 +465,8 @@ ngx_signal_worker_processes(ngx_cycle_t
+     ngx_err_t      err;
+     ngx_channel_t  ch;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+ #if (NGX_BROKEN_SCM_RIGHTS)
+ 
+     ch.command = 0;
+@@ -564,6 +568,8 @@ ngx_reap_children(ngx_cycle_t *cycle)
+     ngx_channel_t     ch;
+     ngx_core_conf_t  *ccf;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_CLOSE_CHANNEL;
+     ch.fd = -1;
+ 

patches/nginx-1.2.5-location_if_inherits_proxy.patch

@@ -0,0 +1,15 @@
+--- nginx-1.2.5/src/http/modules/ngx_http_proxy_module.c	2012-04-23 18:40:01.000000000 +0800
++++ nginx-1.2.5-patched/src/http/modules/ngx_http_proxy_module.c	2012-06-24 12:48:57.289834450 +0800
+@@ -3023,8 +3023,10 @@
+ 
+     if (conf->upstream.upstream || conf->proxy_lengths) {
+         clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
+-        if (clcf->handler == NULL && clcf->lmt_excpt) {
+-            clcf->handler = ngx_http_proxy_handler;
++        if (clcf->handler == NULL) {
++            if (clcf->lmt_excpt) {
++                clcf->handler = ngx_http_proxy_handler;
++            }
+             conf->location = prev->location;
+         }
+     }

patches/nginx-1.2.5-log_escape_non_ascii.patch

@@ -0,0 +1,115 @@
+--- nginx-1.2.5/src/http/modules/ngx_http_log_module.c	2011-11-01 21:24:50.000000000 +0800
++++ nginx-1.2.5-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.2.5-no_Werror.patch

@@ -0,0 +1,24 @@
+diff -ur nginx-1.2.5/auto/cc/gcc nginx-1.2.5-patched/auto/cc/gcc
+--- nginx-1.2.5/auto/cc/gcc	2011-06-27 19:53:00.205737804 +0800
++++ nginx-1.2.5-patched/auto/cc/gcc	2011-06-27 19:53:13.837741087 +0800
+@@ -169,7 +169,7 @@
+ 
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"
+diff -ur nginx-1.2.5/auto/cc/icc nginx-1.2.5-patched/auto/cc/icc
+--- nginx-1.2.5/auto/cc/icc	2011-06-27 19:52:56.370157068 +0800
++++ nginx-1.2.5-patched/auto/cc/icc	2011-06-27 19:53:19.508916811 +0800
+@@ -139,7 +139,7 @@
+ esac
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"

patches/nginx-1.2.5-no_error_pages.patch

@@ -0,0 +1,90 @@
+--- nginx-1.2.5/src/http/ngx_http_core_module.c	2010-12-14 18:38:42.000000000 +0800
++++ nginx-1.2.5-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.2.5-no_pool.patch

@@ -0,0 +1,609 @@
+diff -ur nginx-1.2.5/src/core/nginx.h nginx-1.2.5-patched/src/core/nginx.h
+--- nginx-1.2.5/src/core/nginx.h	2011-08-29 17:30:22.000000000 +0800
++++ nginx-1.2.5-patched/src/core/nginx.h	2011-09-13 12:11:03.135622101 +0800
+@@ -10,7 +10,7 @@
+ 
+ 
+ #define nginx_version      1002005
+ #define NGINX_VERSION      "1.2.5"
+-#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown (no pool)"
+ 
+ #define NGINX_VAR          "NGINX"
+diff -urx '*~' -x '*.swp' nginx-1.2.5/src/core/ngx_array.c nginx-1.2.5-patched/src/core/ngx_array.c
+--- nginx-1.2.5/src/core/ngx_array.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.5-patched/src/core/ngx_array.c	2012-06-20 23:10:36.870722387 +0800
+@@ -28,6 +28,7 @@
+     a->size = size;
+     a->nalloc = n;
+     a->pool = p;
++    a->old_elts = NULL;
+ 
+     return a;
+ }
+@@ -36,26 +37,30 @@
+ 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) {
+ 
+@@ -65,29 +70,27 @@
+ 
+         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++;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            new = ngx_palloc(p, 2 * size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, size);
+-            a->elts = new;
+-            a->nalloc *= 2;
++        /* allocate a new array */
++
++        new = ngx_palloc(p, 2 * size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, size);
++
++        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;
+@@ -101,11 +104,10 @@
+ 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) {
+ 
+@@ -113,31 +115,27 @@
+ 
+         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
+-             */
+-
+-            p->d.last += size;
+-            a->nalloc += n;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
+-
+-            new = ngx_palloc(p, nalloc * a->size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, a->nelts * a->size);
+-            a->elts = new;
+-            a->nalloc = nalloc;
++        nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
++
++        new = ngx_palloc(p, nalloc * a->size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, a->nelts * a->size);
++
++        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 = nalloc;
+     }
+ 
+     elt = (u_char *) a->elts + a->size * a->nelts;
+diff -urx '*~' -x '*.swp' nginx-1.2.5/src/core/ngx_array.h nginx-1.2.5-patched/src/core/ngx_array.h
+--- nginx-1.2.5/src/core/ngx_array.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.5-patched/src/core/ngx_array.h	2012-06-20 23:25:38.800624960 +0800
+@@ -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;
++};
++
++
+ struct ngx_array_s {
+     void        *elts;
+     ngx_uint_t   nelts;
+     size_t       size;
+     ngx_uint_t   nalloc;
+     ngx_pool_t  *pool;
++
++    ngx_array_link_t *old_elts;
+ };
+ 
+ 
+@@ -40,6 +51,7 @@
+     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 -urx '*~' -x '*.swp' nginx-1.2.5/src/core/ngx_palloc.c nginx-1.2.5-patched/src/core/ngx_palloc.c
+--- nginx-1.2.5/src/core/ngx_palloc.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.5-patched/src/core/ngx_palloc.c	2012-06-20 22:56:30.148073066 +0800
+@@ -9,32 +9,23 @@
+ #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);
+-
+-
+ 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 +35,7 @@
+ 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 +46,9 @@
+         }
+     }
+ 
+-    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 +58,9 @@
+      * 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,172 +69,82 @@
+ 
+ #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;
+ 
+-void
+-ngx_reset_pool(ngx_pool_t *pool)
+-{
+-    ngx_pool_t        *p;
+-    ngx_pool_large_t  *l;
+-
+-    for (l = pool->large; l; l = l->next) {
+-        if (l->alloc) {
+-            ngx_free(l->alloc);
+-        }
+-    }
+-
+-    pool->large = NULL;
+-
+-    for (p = pool; p; p = p->d.next) {
+-        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
+-    }
++    ngx_free(pool);
+ }
+ 
+ 
+-void *
+-ngx_palloc(ngx_pool_t *pool, size_t size)
++void
++ngx_reset_pool(ngx_pool_t *pool)
+ {
+-    u_char      *m;
+-    ngx_pool_t  *p;
+-
+-    if (size <= pool->max) {
++    ngx_pool_data_t     *d, *n;
++    ngx_pool_data_t     *saved = NULL;
+ 
+-        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;
++    if (pool->d) {
++        for (d = pool->d, n = d->next; ; d = n, n = n->next) {
++            if (d->alloc == pool->log) {
++                saved = d;
++                continue;
+             }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
+-    }
+-
+-    return ngx_palloc_large(pool, size);
+-}
+-
++            ngx_free(d->alloc);
++            ngx_free(d);
+ 
+-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;
++            if (n == NULL) {
++                break;
+             }
++        }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
++        pool->d = saved;
+     }
+-
+-    return ngx_palloc_large(pool, size);
+ }
+ 
+ 
+-static void *
+-ngx_palloc_block(ngx_pool_t *pool, size_t size)
++void *
++ngx_malloc(ngx_pool_t *pool, size_t size)
+ {
+-    u_char      *m;
+-    size_t       psize;
+-    ngx_pool_t  *p, *new, *current;
++    ngx_pool_data_t     *d;
++    void                *p;
+ 
+-    psize = (size_t) (pool->d.end - (u_char *) pool);
+-
+-    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
+-    if (m == NULL) {
++    p = ngx_alloc(size, pool->log);
++    if (p == 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;
+-
+-    current = pool->current;
+-
+-    for (p = current; p->d.next; p = p->d.next) {
+-        if (p->d.failed++ > 4) {
+-            current = p->d.next;
+-        }
++    d = ngx_alloc(sizeof(ngx_pool_data_t), pool->log);
++    if (d == NULL){
++        ngx_free(p);
++        return NULL;
+     }
+ 
+-    p->d.next = new;
+-
+-    pool->current = current ? current : new;
+-
+-    return m;
++    d->alloc = p;
++    d->next = pool->d;
++    pool->d = d;
++    return p;
+ }
+ 
+ 
+-static void *
+-ngx_palloc_large(ngx_pool_t *pool, size_t size)
++void *
++ngx_palloc(ngx_pool_t *pool, size_t size)
+ {
+-    void              *p;
+-    ngx_uint_t         n;
+-    ngx_pool_large_t  *large;
+-
+-    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) {
+-        ngx_free(p);
+-        return NULL;
+-    }
++    return ngx_malloc(pool, size);
++}
+ 
+-    large->alloc = p;
+-    large->next = pool->large;
+-    pool->large = large;
+ 
+-    return p;
++void *
++ngx_pnalloc(ngx_pool_t *pool, size_t size)
++{
++    return ngx_malloc(pool, size);
+ }
+ 
+ 
+@@ -256,38 +152,48 @@
+ 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 -urx '*~' -x '*.swp' nginx-1.2.5/src/core/ngx_palloc.h nginx-1.2.5-patched/src/core/ngx_palloc.h
+--- nginx-1.2.5/src/core/ngx_palloc.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.5-patched/src/core/ngx_palloc.h	2012-06-21 10:35:47.463405863 +0800
+@@ -38,28 +38,21 @@
+ };
+ 
+ 
+-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.2.5-nonbuffered-upstream-truncation.patch

@@ -0,0 +1,63 @@
+--- nginx-1.2.5/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.2.5-patched/src/http/ngx_http_upstream.c	2012-09-09 21:58:04.727761891 -0700
+@@ -2383,7 +2383,7 @@
+ 
+     if (c->read->timedout) {
+         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
+-        ngx_http_upstream_finalize_request(r, u, 0);
++        ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
+         return;
+     }
+ 
+@@ -2430,13 +2430,17 @@
+             if (u->busy_bufs == NULL) {
+ 
+                 if (u->length == 0
+-                    || upstream->read->eof
+-                    || upstream->read->error)
++                    || (upstream->read->eof && u->headers_in.content_length_n == -1))
+                 {
+                     ngx_http_upstream_finalize_request(r, u, 0);
+                     return;
+                 }
+ 
++                if (upstream->read->eof || upstream->read->error) {
++                    ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++                    return;
++                }
++
+                 b->pos = b->start;
+                 b->last = b->start;
+             }
+@@ -2710,7 +2714,16 @@
+ #if 0
+             ngx_http_busy_unlock(u->conf->busy_lock, &u->busy_lock);
+ #endif
+-            ngx_http_upstream_finalize_request(r, u, 0);
++
++            if (p->upstream_done
++                || (p->upstream_eof && u->headers_in.content_length_n == -1))
++            {
++                ngx_http_upstream_finalize_request(r, u, 0);
++
++            } else {
++                ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++            }
++
+             return;
+         }
+     }
+@@ -3073,6 +3086,13 @@
+         && rc != NGX_HTTP_REQUEST_TIME_OUT
+         && (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
+     {
++        if (rc == NGX_ERROR) {
++            r->headers_out.status = NGX_HTTP_INTERNAL_SERVER_ERROR;
++
++        } else {
++            r->headers_out.status = rc;
++        }
++
+         rc = 0;
+     }
+ 

patches/nginx-1.2.5-server_header.patch

@@ -0,0 +1,26 @@
+diff -ur lz-nginx-1.2.5/nginx-1.2.5/src/core/nginx.h lz-nginx-1.2.5-patched/nginx-1.2.5/src/core/nginx.h
+--- lz-nginx-1.2.5/nginx-1.2.5/src/core/nginx.h	2010-02-12 17:31:01.000000000 +0800
++++ lz-nginx-1.2.5-patched/nginx-1.2.5/src/core/nginx.h	2010-03-30 10:52:13.240702627 +0800
+@@ -10,7 +10,7 @@
+ 
+ #define nginx_version         1002005
+ #define NGINX_VERSION      "1.2.5"
+-#define NGINX_VER          "nginx/" NGINX_VERSION
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
+ 
+ #define NGINX_VAR          "NGINX"
+ #define NGX_OLDPID_EXT     ".oldbin"
+Only in lz-nginx-1.2.5-patched/nginx-1.2.5/src/core: nginx.h.orig
+Only in lz-nginx-1.2.5-patched/nginx-1.2.5/src/core: nginx.h.rej
+diff -ur lz-nginx-1.2.5/nginx-1.2.5/src/http/ngx_http_header_filter_module.c lz-nginx-1.2.5-patched/nginx-1.2.5/src/http/ngx_http_header_filter_module.c
+--- lz-nginx-1.2.5/nginx-1.2.5/src/http/ngx_http_header_filter_module.c	2010-03-03 23:14:04.000000000 +0800
++++ lz-nginx-1.2.5-patched/nginx-1.2.5/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: ngx_openresty" CRLF;
+ static char ngx_http_server_full_string[] = "Server: " NGINX_VER CRLF;
+ 
+ 

patches/nginx-1.2.5-slab_alloc_no_memory_as_info.patch

@@ -0,0 +1,11 @@
+--- nginx-1.2.5/src/core/ngx_slab.c	2012-09-24 11:34:04.000000000 -0700
++++ nginx-1.2.5-patched/src/core/ngx_slab.c	2012-12-05 20:47:07.296694952 -0800
+@@ -657,7 +657,7 @@ ngx_slab_alloc_pages(ngx_slab_pool_t *po
+         }
+     }
+ 
+-    ngx_slab_error(pool, NGX_LOG_CRIT, "ngx_slab_alloc() failed: no memory");
++    ngx_slab_error(pool, NGX_LOG_INFO, "ngx_slab_alloc() failed: no memory");
+ 
+     return NULL;
+ }

patches/nginx-1.2.5-upstream_pipelining.patch

@@ -0,0 +1,40 @@
+diff -rudp nginx-1.2.5/src/http/ngx_http_upstream.c nginx-1.2.5-patched/src/http/ngx_http_upstream.c
+--- nginx-1.2.5/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.2.5-patched/src/http/ngx_http_upstream.c	2012-12-05 14:46:41.741173058 -0800
+@@ -1216,6 +1216,7 @@ ngx_http_upstream_connect(ngx_http_reque
+     }
+ 
+     u->request_sent = 0;
++    u->request_all_sent = 0;
+ 
+     if (rc == NGX_AGAIN) {
+         ngx_add_timer(c->write, u->conf->connect_timeout);
+@@ -1418,6 +1419,8 @@ ngx_http_upstream_send_request(ngx_http_
+ 
+     /* rc == NGX_OK */
+ 
++    u->request_all_sent = 1;
++
+     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
+         if (ngx_tcp_push(c->fd) == NGX_ERROR) {
+             ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
+@@ -1484,7 +1487,7 @@ ngx_http_upstream_send_request_handler(n
+ 
+ #endif
+ 
+-    if (u->header_sent) {
++    if (u->request_all_sent) {
+         u->write_event_handler = ngx_http_upstream_dummy_handler;
+ 
+         (void) ngx_handle_write_event(c->write, 0);
+diff -rudp nginx-1.2.5/src/http/ngx_http_upstream.h nginx-1.2.5-patched/src/http/ngx_http_upstream.h
+--- nginx-1.2.5/src/http/ngx_http_upstream.h	2012-02-13 03:01:58.000000000 -0800
++++ nginx-1.2.5-patched/src/http/ngx_http_upstream.h	2012-12-05 14:41:09.763514741 -0800
+@@ -324,6 +324,7 @@ struct ngx_http_upstream_s {
+     unsigned                         keepalive:1;
+ 
+     unsigned                         request_sent:1;
++    unsigned                         request_all_sent:1;
+     unsigned                         header_sent:1;
+ };
+ 

patches/nginx-1.2.5-upstream_test_connect_kqueue.patch

@@ -0,0 +1,26 @@
+--- nginx-1.2.5/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.2.5-patched/src/http/ngx_http_upstream.c	2012-11-05 21:17:38.000000000 -0800
+@@ -1808,10 +1808,22 @@ ngx_http_upstream_test_connect(ngx_conne
+ 
+ #if (NGX_HAVE_KQUEUE)
+ 
++    ngx_event_t *ev;
++
+     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT)  {
+         if (c->write->pending_eof) {
++            ev = c->write;
++
++        } else if (c->read->pending_eof) {
++            ev = c->read;
++
++        } else {
++            ev = NULL;
++        }
++
++        if (ev) {
+             c->log->action = "connecting to upstream";
+-            (void) ngx_connection_error(c, c->write->kq_errno,
++            (void) ngx_connection_error(c, ev->kq_errno,
+                                     "kevent() reported that connect() failed");
+             return NGX_ERROR;
+         }

patches/nginx-1.2.6-channel-uninit-params.patch

@@ -0,0 +1,42 @@
+diff -urp nginx-1.2.6/src/os/unix/ngx_channel.c nginx-1.2.6-patched/src/os/unix/ngx_channel.c
+--- nginx-1.2.6/src/os/unix/ngx_channel.c	2012-01-18 07:07:43.000000000 -0800
++++ nginx-1.2.6-patched/src/os/unix/ngx_channel.c	2012-09-17 11:33:09.215394217 -0700
+@@ -31,6 +31,8 @@ ngx_write_channel(ngx_socket_t s, ngx_ch
+         msg.msg_controllen = 0;
+ 
+     } else {
++        ngx_memzero(&cmsg, sizeof(cmsg));
++
+         msg.msg_control = (caddr_t) &cmsg;
+         msg.msg_controllen = sizeof(cmsg);
+ 
+diff -urp nginx-1.2.6/src/os/unix/ngx_process_cycle.c nginx-1.2.6-patched/src/os/unix/ngx_process_cycle.c
+--- nginx-1.2.6/src/os/unix/ngx_process_cycle.c	2012-07-02 09:23:14.000000000 -0700
++++ nginx-1.2.6-patched/src/os/unix/ngx_process_cycle.c	2012-09-17 11:33:09.214394215 -0700
+@@ -356,6 +356,8 @@ ngx_start_worker_processes(ngx_cycle_t *
+ 
+     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_OPEN_CHANNEL;
+ 
+     for (i = 0; i < n; i++) {
+@@ -463,6 +465,8 @@ ngx_signal_worker_processes(ngx_cycle_t
+     ngx_err_t      err;
+     ngx_channel_t  ch;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+ #if (NGX_BROKEN_SCM_RIGHTS)
+ 
+     ch.command = 0;
+@@ -564,6 +568,8 @@ ngx_reap_children(ngx_cycle_t *cycle)
+     ngx_channel_t     ch;
+     ngx_core_conf_t  *ccf;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_CLOSE_CHANNEL;
+     ch.fd = -1;
+ 

patches/nginx-1.2.6-location_if_inherits_proxy.patch

@@ -0,0 +1,15 @@
+--- nginx-1.2.6/src/http/modules/ngx_http_proxy_module.c	2012-04-23 18:40:01.000000000 +0800
++++ nginx-1.2.6-patched/src/http/modules/ngx_http_proxy_module.c	2012-06-24 12:48:57.289834450 +0800
+@@ -3023,8 +3023,10 @@
+ 
+     if (conf->upstream.upstream || conf->proxy_lengths) {
+         clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
+-        if (clcf->handler == NULL && clcf->lmt_excpt) {
+-            clcf->handler = ngx_http_proxy_handler;
++        if (clcf->handler == NULL) {
++            if (clcf->lmt_excpt) {
++                clcf->handler = ngx_http_proxy_handler;
++            }
+             conf->location = prev->location;
+         }
+     }

patches/nginx-1.2.6-log_escape_non_ascii.patch

@@ -0,0 +1,115 @@
+--- nginx-1.2.6/src/http/modules/ngx_http_log_module.c	2011-11-01 21:24:50.000000000 +0800
++++ nginx-1.2.6-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.2.6-no_Werror.patch

@@ -0,0 +1,24 @@
+diff -ur nginx-1.2.6/auto/cc/gcc nginx-1.2.6-patched/auto/cc/gcc
+--- nginx-1.2.6/auto/cc/gcc	2011-06-27 19:53:00.205737804 +0800
++++ nginx-1.2.6-patched/auto/cc/gcc	2011-06-27 19:53:13.837741087 +0800
+@@ -169,7 +169,7 @@
+ 
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"
+diff -ur nginx-1.2.6/auto/cc/icc nginx-1.2.6-patched/auto/cc/icc
+--- nginx-1.2.6/auto/cc/icc	2011-06-27 19:52:56.370157068 +0800
++++ nginx-1.2.6-patched/auto/cc/icc	2011-06-27 19:53:19.508916811 +0800
+@@ -139,7 +139,7 @@
+ esac
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"

patches/nginx-1.2.6-no_error_pages.patch

@@ -0,0 +1,90 @@
+--- nginx-1.2.6/src/http/ngx_http_core_module.c	2010-12-14 18:38:42.000000000 +0800
++++ nginx-1.2.6-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.2.6-no_pool.patch

@@ -0,0 +1,609 @@
+diff -ur nginx-1.2.6/src/core/nginx.h nginx-1.2.6-patched/src/core/nginx.h
+--- nginx-1.2.6/src/core/nginx.h	2011-08-29 17:30:22.000000000 +0800
++++ nginx-1.2.6-patched/src/core/nginx.h	2011-09-13 12:11:03.135622101 +0800
+@@ -10,7 +10,7 @@
+ 
+ 
+ #define nginx_version      1002006
+ #define NGINX_VERSION      "1.2.6"
+-#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown (no pool)"
+ 
+ #define NGINX_VAR          "NGINX"
+diff -urx '*~' -x '*.swp' nginx-1.2.6/src/core/ngx_array.c nginx-1.2.6-patched/src/core/ngx_array.c
+--- nginx-1.2.6/src/core/ngx_array.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.6-patched/src/core/ngx_array.c	2012-06-20 23:10:36.870722387 +0800
+@@ -28,6 +28,7 @@
+     a->size = size;
+     a->nalloc = n;
+     a->pool = p;
++    a->old_elts = NULL;
+ 
+     return a;
+ }
+@@ -36,26 +37,30 @@
+ 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) {
+ 
+@@ -65,29 +70,27 @@
+ 
+         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++;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            new = ngx_palloc(p, 2 * size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, size);
+-            a->elts = new;
+-            a->nalloc *= 2;
++        /* allocate a new array */
++
++        new = ngx_palloc(p, 2 * size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, size);
++
++        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;
+@@ -101,11 +104,10 @@
+ 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) {
+ 
+@@ -113,31 +115,27 @@
+ 
+         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
+-             */
+-
+-            p->d.last += size;
+-            a->nalloc += n;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
+-
+-            new = ngx_palloc(p, nalloc * a->size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, a->nelts * a->size);
+-            a->elts = new;
+-            a->nalloc = nalloc;
++        nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
++
++        new = ngx_palloc(p, nalloc * a->size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, a->nelts * a->size);
++
++        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 = nalloc;
+     }
+ 
+     elt = (u_char *) a->elts + a->size * a->nelts;
+diff -urx '*~' -x '*.swp' nginx-1.2.6/src/core/ngx_array.h nginx-1.2.6-patched/src/core/ngx_array.h
+--- nginx-1.2.6/src/core/ngx_array.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.6-patched/src/core/ngx_array.h	2012-06-20 23:25:38.800624960 +0800
+@@ -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;
++};
++
++
+ struct ngx_array_s {
+     void        *elts;
+     ngx_uint_t   nelts;
+     size_t       size;
+     ngx_uint_t   nalloc;
+     ngx_pool_t  *pool;
++
++    ngx_array_link_t *old_elts;
+ };
+ 
+ 
+@@ -40,6 +51,7 @@
+     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 -urx '*~' -x '*.swp' nginx-1.2.6/src/core/ngx_palloc.c nginx-1.2.6-patched/src/core/ngx_palloc.c
+--- nginx-1.2.6/src/core/ngx_palloc.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.6-patched/src/core/ngx_palloc.c	2012-06-20 22:56:30.148073066 +0800
+@@ -9,32 +9,23 @@
+ #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);
+-
+-
+ 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 +35,7 @@
+ 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 +46,9 @@
+         }
+     }
+ 
+-    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 +58,9 @@
+      * 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,172 +69,82 @@
+ 
+ #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;
+ 
+-void
+-ngx_reset_pool(ngx_pool_t *pool)
+-{
+-    ngx_pool_t        *p;
+-    ngx_pool_large_t  *l;
+-
+-    for (l = pool->large; l; l = l->next) {
+-        if (l->alloc) {
+-            ngx_free(l->alloc);
+-        }
+-    }
+-
+-    pool->large = NULL;
+-
+-    for (p = pool; p; p = p->d.next) {
+-        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
+-    }
++    ngx_free(pool);
+ }
+ 
+ 
+-void *
+-ngx_palloc(ngx_pool_t *pool, size_t size)
++void
++ngx_reset_pool(ngx_pool_t *pool)
+ {
+-    u_char      *m;
+-    ngx_pool_t  *p;
+-
+-    if (size <= pool->max) {
++    ngx_pool_data_t     *d, *n;
++    ngx_pool_data_t     *saved = NULL;
+ 
+-        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;
++    if (pool->d) {
++        for (d = pool->d, n = d->next; ; d = n, n = n->next) {
++            if (d->alloc == pool->log) {
++                saved = d;
++                continue;
+             }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
+-    }
+-
+-    return ngx_palloc_large(pool, size);
+-}
+-
++            ngx_free(d->alloc);
++            ngx_free(d);
+ 
+-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;
++            if (n == NULL) {
++                break;
+             }
++        }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
++        pool->d = saved;
+     }
+-
+-    return ngx_palloc_large(pool, size);
+ }
+ 
+ 
+-static void *
+-ngx_palloc_block(ngx_pool_t *pool, size_t size)
++void *
++ngx_malloc(ngx_pool_t *pool, size_t size)
+ {
+-    u_char      *m;
+-    size_t       psize;
+-    ngx_pool_t  *p, *new, *current;
++    ngx_pool_data_t     *d;
++    void                *p;
+ 
+-    psize = (size_t) (pool->d.end - (u_char *) pool);
+-
+-    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
+-    if (m == NULL) {
++    p = ngx_alloc(size, pool->log);
++    if (p == 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;
+-
+-    current = pool->current;
+-
+-    for (p = current; p->d.next; p = p->d.next) {
+-        if (p->d.failed++ > 4) {
+-            current = p->d.next;
+-        }
++    d = ngx_alloc(sizeof(ngx_pool_data_t), pool->log);
++    if (d == NULL){
++        ngx_free(p);
++        return NULL;
+     }
+ 
+-    p->d.next = new;
+-
+-    pool->current = current ? current : new;
+-
+-    return m;
++    d->alloc = p;
++    d->next = pool->d;
++    pool->d = d;
++    return p;
+ }
+ 
+ 
+-static void *
+-ngx_palloc_large(ngx_pool_t *pool, size_t size)
++void *
++ngx_palloc(ngx_pool_t *pool, size_t size)
+ {
+-    void              *p;
+-    ngx_uint_t         n;
+-    ngx_pool_large_t  *large;
+-
+-    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) {
+-        ngx_free(p);
+-        return NULL;
+-    }
++    return ngx_malloc(pool, size);
++}
+ 
+-    large->alloc = p;
+-    large->next = pool->large;
+-    pool->large = large;
+ 
+-    return p;
++void *
++ngx_pnalloc(ngx_pool_t *pool, size_t size)
++{
++    return ngx_malloc(pool, size);
+ }
+ 
+ 
+@@ -256,38 +152,48 @@
+ 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 -urx '*~' -x '*.swp' nginx-1.2.6/src/core/ngx_palloc.h nginx-1.2.6-patched/src/core/ngx_palloc.h
+--- nginx-1.2.6/src/core/ngx_palloc.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.6-patched/src/core/ngx_palloc.h	2012-06-21 10:35:47.463405863 +0800
+@@ -38,28 +38,21 @@
+ };
+ 
+ 
+-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.2.6-nonbuffered-upstream-truncation.patch

@@ -0,0 +1,63 @@
+--- nginx-1.2.6/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.2.6-patched/src/http/ngx_http_upstream.c	2012-09-09 21:58:04.727761891 -0700
+@@ -2383,7 +2383,7 @@
+ 
+     if (c->read->timedout) {
+         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
+-        ngx_http_upstream_finalize_request(r, u, 0);
++        ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
+         return;
+     }
+ 
+@@ -2430,13 +2430,17 @@
+             if (u->busy_bufs == NULL) {
+ 
+                 if (u->length == 0
+-                    || upstream->read->eof
+-                    || upstream->read->error)
++                    || (upstream->read->eof && u->headers_in.content_length_n == -1))
+                 {
+                     ngx_http_upstream_finalize_request(r, u, 0);
+                     return;
+                 }
+ 
++                if (upstream->read->eof || upstream->read->error) {
++                    ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++                    return;
++                }
++
+                 b->pos = b->start;
+                 b->last = b->start;
+             }
+@@ -2710,7 +2714,16 @@
+ #if 0
+             ngx_http_busy_unlock(u->conf->busy_lock, &u->busy_lock);
+ #endif
+-            ngx_http_upstream_finalize_request(r, u, 0);
++
++            if (p->upstream_done
++                || (p->upstream_eof && u->headers_in.content_length_n == -1))
++            {
++                ngx_http_upstream_finalize_request(r, u, 0);
++
++            } else {
++                ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++            }
++
+             return;
+         }
+     }
+@@ -3073,6 +3086,13 @@
+         && rc != NGX_HTTP_REQUEST_TIME_OUT
+         && (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
+     {
++        if (rc == NGX_ERROR) {
++            r->headers_out.status = NGX_HTTP_INTERNAL_SERVER_ERROR;
++
++        } else {
++            r->headers_out.status = rc;
++        }
++
+         rc = 0;
+     }
+ 

patches/nginx-1.2.6-resolver_wev_handler_segfault_with_poll.patch

@@ -0,0 +1,31 @@
+--- nginx-1.2.6/src/event/modules/ngx_poll_module.c	2012-01-18 07:07:43.000000000 -0800
++++ nginx-1.2.6-patched/src/event/modules/ngx_poll_module.c	2013-01-23 12:34:13.990781456 -0800
+@@ -367,11 +367,18 @@ ngx_poll_process_events(ngx_cycle_t *cyc
+              */
+ 
+             revents |= POLLIN|POLLOUT;
++            if (c->read->active) {
++                revents |= POLLIN;
++            }
++
++            if (c->write->active) {
++                revents |= POLLOUT;
++            }
+         }
+ 
+         found = 0;
+ 
+-        if (revents & POLLIN) {
++        if ((revents & POLLIN) && c->read->active) {
+             found = 1;
+ 
+             ev = c->read;
+@@ -388,7 +395,7 @@ ngx_poll_process_events(ngx_cycle_t *cyc
+             ngx_locked_post_event(ev, queue);
+         }
+ 
+-        if (revents & POLLOUT) {
++        if ((revents & POLLOUT) && c->write->active) {
+             found = 1;
+             ev = c->write;
+ 

patches/nginx-1.2.6-server_header.patch

@@ -0,0 +1,26 @@
+diff -ur lz-nginx-1.2.6/nginx-1.2.6/src/core/nginx.h lz-nginx-1.2.6-patched/nginx-1.2.6/src/core/nginx.h
+--- lz-nginx-1.2.6/nginx-1.2.6/src/core/nginx.h	2010-02-12 17:31:01.000000000 +0800
++++ lz-nginx-1.2.6-patched/nginx-1.2.6/src/core/nginx.h	2010-03-30 10:52:13.240702627 +0800
+@@ -10,7 +10,7 @@
+ 
+ #define nginx_version         1002006
+ #define NGINX_VERSION      "1.2.6"
+-#define NGINX_VER          "nginx/" NGINX_VERSION
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
+ 
+ #define NGINX_VAR          "NGINX"
+ #define NGX_OLDPID_EXT     ".oldbin"
+Only in lz-nginx-1.2.6-patched/nginx-1.2.6/src/core: nginx.h.orig
+Only in lz-nginx-1.2.6-patched/nginx-1.2.6/src/core: nginx.h.rej
+diff -ur lz-nginx-1.2.6/nginx-1.2.6/src/http/ngx_http_header_filter_module.c lz-nginx-1.2.6-patched/nginx-1.2.6/src/http/ngx_http_header_filter_module.c
+--- lz-nginx-1.2.6/nginx-1.2.6/src/http/ngx_http_header_filter_module.c	2010-03-03 23:14:04.000000000 +0800
++++ lz-nginx-1.2.6-patched/nginx-1.2.6/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: ngx_openresty" CRLF;
+ static char ngx_http_server_full_string[] = "Server: " NGINX_VER CRLF;
+ 
+ 

patches/nginx-1.2.6-slab_alloc_no_memory_as_info.patch

@@ -0,0 +1,11 @@
+--- nginx-1.2.6/src/core/ngx_slab.c	2012-09-24 11:34:04.000000000 -0700
++++ nginx-1.2.6-patched/src/core/ngx_slab.c	2012-12-05 20:47:07.296694952 -0800
+@@ -657,7 +657,7 @@ ngx_slab_alloc_pages(ngx_slab_pool_t *po
+         }
+     }
+ 
+-    ngx_slab_error(pool, NGX_LOG_CRIT, "ngx_slab_alloc() failed: no memory");
++    ngx_slab_error(pool, NGX_LOG_INFO, "ngx_slab_alloc() failed: no memory");
+ 
+     return NULL;
+ }

patches/nginx-1.2.6-upstream_pipelining.patch

@@ -0,0 +1,40 @@
+diff -rudp nginx-1.2.6/src/http/ngx_http_upstream.c nginx-1.2.6-patched/src/http/ngx_http_upstream.c
+--- nginx-1.2.6/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.2.6-patched/src/http/ngx_http_upstream.c	2012-12-05 14:46:41.741173058 -0800
+@@ -1216,6 +1216,7 @@ ngx_http_upstream_connect(ngx_http_reque
+     }
+ 
+     u->request_sent = 0;
++    u->request_all_sent = 0;
+ 
+     if (rc == NGX_AGAIN) {
+         ngx_add_timer(c->write, u->conf->connect_timeout);
+@@ -1418,6 +1419,8 @@ ngx_http_upstream_send_request(ngx_http_
+ 
+     /* rc == NGX_OK */
+ 
++    u->request_all_sent = 1;
++
+     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
+         if (ngx_tcp_push(c->fd) == NGX_ERROR) {
+             ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
+@@ -1484,7 +1487,7 @@ ngx_http_upstream_send_request_handler(n
+ 
+ #endif
+ 
+-    if (u->header_sent) {
++    if (u->request_all_sent) {
+         u->write_event_handler = ngx_http_upstream_dummy_handler;
+ 
+         (void) ngx_handle_write_event(c->write, 0);
+diff -rudp nginx-1.2.6/src/http/ngx_http_upstream.h nginx-1.2.6-patched/src/http/ngx_http_upstream.h
+--- nginx-1.2.6/src/http/ngx_http_upstream.h	2012-02-13 03:01:58.000000000 -0800
++++ nginx-1.2.6-patched/src/http/ngx_http_upstream.h	2012-12-05 14:41:09.763514741 -0800
+@@ -324,6 +324,7 @@ struct ngx_http_upstream_s {
+     unsigned                         keepalive:1;
+ 
+     unsigned                         request_sent:1;
++    unsigned                         request_all_sent:1;
+     unsigned                         header_sent:1;
+ };
+ 

patches/nginx-1.2.7-channel-uninit-params.patch

@@ -0,0 +1,42 @@
+diff -urp nginx-1.2.7/src/os/unix/ngx_channel.c nginx-1.2.7-patched/src/os/unix/ngx_channel.c
+--- nginx-1.2.7/src/os/unix/ngx_channel.c	2012-01-18 07:07:43.000000000 -0800
++++ nginx-1.2.7-patched/src/os/unix/ngx_channel.c	2012-09-17 11:33:09.215394217 -0700
+@@ -31,6 +31,8 @@ ngx_write_channel(ngx_socket_t s, ngx_ch
+         msg.msg_controllen = 0;
+ 
+     } else {
++        ngx_memzero(&cmsg, sizeof(cmsg));
++
+         msg.msg_control = (caddr_t) &cmsg;
+         msg.msg_controllen = sizeof(cmsg);
+ 
+diff -urp nginx-1.2.7/src/os/unix/ngx_process_cycle.c nginx-1.2.7-patched/src/os/unix/ngx_process_cycle.c
+--- nginx-1.2.7/src/os/unix/ngx_process_cycle.c	2012-07-02 09:23:14.000000000 -0700
++++ nginx-1.2.7-patched/src/os/unix/ngx_process_cycle.c	2012-09-17 11:33:09.214394215 -0700
+@@ -356,6 +356,8 @@ ngx_start_worker_processes(ngx_cycle_t *
+ 
+     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_OPEN_CHANNEL;
+ 
+     for (i = 0; i < n; i++) {
+@@ -463,6 +465,8 @@ ngx_signal_worker_processes(ngx_cycle_t
+     ngx_err_t      err;
+     ngx_channel_t  ch;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+ #if (NGX_BROKEN_SCM_RIGHTS)
+ 
+     ch.command = 0;
+@@ -564,6 +568,8 @@ ngx_reap_children(ngx_cycle_t *cycle)
+     ngx_channel_t     ch;
+     ngx_core_conf_t  *ccf;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_CLOSE_CHANNEL;
+     ch.fd = -1;
+ 

patches/nginx-1.2.7-cve-2013-2070.patch

@@ -0,0 +1,13 @@
+--- src/http/modules/ngx_http_proxy_module.c
++++ src/http/modules/ngx_http_proxy_module.c
+@@ -1865,6 +1865,10 @@ data:
+ 
+     }
+ 
++    if (ctx->size < 0 || ctx->length < 0) {
++        goto invalid;
++    }
++
+     return rc;
+ 
+ done:

patches/nginx-1.2.7-location_if_inherits_proxy.patch

@@ -0,0 +1,15 @@
+--- nginx-1.2.7/src/http/modules/ngx_http_proxy_module.c	2012-04-23 18:40:01.000000000 +0800
++++ nginx-1.2.7-patched/src/http/modules/ngx_http_proxy_module.c	2012-06-24 12:48:57.289834450 +0800
+@@ -3023,8 +3023,10 @@
+ 
+     if (conf->upstream.upstream || conf->proxy_lengths) {
+         clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
+-        if (clcf->handler == NULL && clcf->lmt_excpt) {
+-            clcf->handler = ngx_http_proxy_handler;
++        if (clcf->handler == NULL) {
++            if (clcf->lmt_excpt) {
++                clcf->handler = ngx_http_proxy_handler;
++            }
+             conf->location = prev->location;
+         }
+     }

patches/nginx-1.2.7-log_escape_non_ascii.patch

@@ -0,0 +1,115 @@
+--- nginx-1.2.7/src/http/modules/ngx_http_log_module.c	2011-11-01 21:24:50.000000000 +0800
++++ nginx-1.2.7-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.2.7-no_Werror.patch

@@ -0,0 +1,24 @@
+diff -ur nginx-1.2.7/auto/cc/gcc nginx-1.2.7-patched/auto/cc/gcc
+--- nginx-1.2.7/auto/cc/gcc	2011-06-27 19:53:00.205737804 +0800
++++ nginx-1.2.7-patched/auto/cc/gcc	2011-06-27 19:53:13.837741087 +0800
+@@ -169,7 +169,7 @@
+ 
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"
+diff -ur nginx-1.2.7/auto/cc/icc nginx-1.2.7-patched/auto/cc/icc
+--- nginx-1.2.7/auto/cc/icc	2011-06-27 19:52:56.370157068 +0800
++++ nginx-1.2.7-patched/auto/cc/icc	2011-06-27 19:53:19.508916811 +0800
+@@ -139,7 +139,7 @@
+ esac
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"

patches/nginx-1.2.7-no_error_pages.patch

@@ -0,0 +1,90 @@
+--- nginx-1.2.7/src/http/ngx_http_core_module.c	2010-12-14 18:38:42.000000000 +0800
++++ nginx-1.2.7-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.2.7-no_pool.patch

@@ -0,0 +1,609 @@
+diff -ur nginx-1.2.7/src/core/nginx.h nginx-1.2.7-patched/src/core/nginx.h
+--- nginx-1.2.7/src/core/nginx.h	2011-08-29 17:30:22.000000000 +0800
++++ nginx-1.2.7-patched/src/core/nginx.h	2011-09-13 12:11:03.135622101 +0800
+@@ -10,7 +10,7 @@
+ 
+ 
+ #define nginx_version      1002007
+ #define NGINX_VERSION      "1.2.7"
+-#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown (no pool)"
+ 
+ #define NGINX_VAR          "NGINX"
+diff -urx '*~' -x '*.swp' nginx-1.2.7/src/core/ngx_array.c nginx-1.2.7-patched/src/core/ngx_array.c
+--- nginx-1.2.7/src/core/ngx_array.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.7-patched/src/core/ngx_array.c	2012-06-20 23:10:36.870722387 +0800
+@@ -28,6 +28,7 @@
+     a->size = size;
+     a->nalloc = n;
+     a->pool = p;
++    a->old_elts = NULL;
+ 
+     return a;
+ }
+@@ -36,26 +37,30 @@
+ 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) {
+ 
+@@ -65,29 +70,27 @@
+ 
+         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++;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            new = ngx_palloc(p, 2 * size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, size);
+-            a->elts = new;
+-            a->nalloc *= 2;
++        /* allocate a new array */
++
++        new = ngx_palloc(p, 2 * size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, size);
++
++        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;
+@@ -101,11 +104,10 @@
+ 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) {
+ 
+@@ -113,31 +115,27 @@
+ 
+         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
+-             */
+-
+-            p->d.last += size;
+-            a->nalloc += n;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
+-
+-            new = ngx_palloc(p, nalloc * a->size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, a->nelts * a->size);
+-            a->elts = new;
+-            a->nalloc = nalloc;
++        nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
++
++        new = ngx_palloc(p, nalloc * a->size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, a->nelts * a->size);
++
++        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 = nalloc;
+     }
+ 
+     elt = (u_char *) a->elts + a->size * a->nelts;
+diff -urx '*~' -x '*.swp' nginx-1.2.7/src/core/ngx_array.h nginx-1.2.7-patched/src/core/ngx_array.h
+--- nginx-1.2.7/src/core/ngx_array.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.7-patched/src/core/ngx_array.h	2012-06-20 23:25:38.800624960 +0800
+@@ -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;
++};
++
++
+ struct ngx_array_s {
+     void        *elts;
+     ngx_uint_t   nelts;
+     size_t       size;
+     ngx_uint_t   nalloc;
+     ngx_pool_t  *pool;
++
++    ngx_array_link_t *old_elts;
+ };
+ 
+ 
+@@ -40,6 +51,7 @@
+     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 -urx '*~' -x '*.swp' nginx-1.2.7/src/core/ngx_palloc.c nginx-1.2.7-patched/src/core/ngx_palloc.c
+--- nginx-1.2.7/src/core/ngx_palloc.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.7-patched/src/core/ngx_palloc.c	2012-06-20 22:56:30.148073066 +0800
+@@ -9,32 +9,23 @@
+ #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);
+-
+-
+ 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 +35,7 @@
+ 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 +46,9 @@
+         }
+     }
+ 
+-    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 +58,9 @@
+      * 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,172 +69,82 @@
+ 
+ #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;
+ 
+-void
+-ngx_reset_pool(ngx_pool_t *pool)
+-{
+-    ngx_pool_t        *p;
+-    ngx_pool_large_t  *l;
+-
+-    for (l = pool->large; l; l = l->next) {
+-        if (l->alloc) {
+-            ngx_free(l->alloc);
+-        }
+-    }
+-
+-    pool->large = NULL;
+-
+-    for (p = pool; p; p = p->d.next) {
+-        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
+-    }
++    ngx_free(pool);
+ }
+ 
+ 
+-void *
+-ngx_palloc(ngx_pool_t *pool, size_t size)
++void
++ngx_reset_pool(ngx_pool_t *pool)
+ {
+-    u_char      *m;
+-    ngx_pool_t  *p;
+-
+-    if (size <= pool->max) {
++    ngx_pool_data_t     *d, *n;
++    ngx_pool_data_t     *saved = NULL;
+ 
+-        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;
++    if (pool->d) {
++        for (d = pool->d, n = d->next; ; d = n, n = n->next) {
++            if (d->alloc == pool->log) {
++                saved = d;
++                continue;
+             }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
+-    }
+-
+-    return ngx_palloc_large(pool, size);
+-}
+-
++            ngx_free(d->alloc);
++            ngx_free(d);
+ 
+-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;
++            if (n == NULL) {
++                break;
+             }
++        }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
++        pool->d = saved;
+     }
+-
+-    return ngx_palloc_large(pool, size);
+ }
+ 
+ 
+-static void *
+-ngx_palloc_block(ngx_pool_t *pool, size_t size)
++void *
++ngx_malloc(ngx_pool_t *pool, size_t size)
+ {
+-    u_char      *m;
+-    size_t       psize;
+-    ngx_pool_t  *p, *new, *current;
++    ngx_pool_data_t     *d;
++    void                *p;
+ 
+-    psize = (size_t) (pool->d.end - (u_char *) pool);
+-
+-    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
+-    if (m == NULL) {
++    p = ngx_alloc(size, pool->log);
++    if (p == 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;
+-
+-    current = pool->current;
+-
+-    for (p = current; p->d.next; p = p->d.next) {
+-        if (p->d.failed++ > 4) {
+-            current = p->d.next;
+-        }
++    d = ngx_alloc(sizeof(ngx_pool_data_t), pool->log);
++    if (d == NULL){
++        ngx_free(p);
++        return NULL;
+     }
+ 
+-    p->d.next = new;
+-
+-    pool->current = current ? current : new;
+-
+-    return m;
++    d->alloc = p;
++    d->next = pool->d;
++    pool->d = d;
++    return p;
+ }
+ 
+ 
+-static void *
+-ngx_palloc_large(ngx_pool_t *pool, size_t size)
++void *
++ngx_palloc(ngx_pool_t *pool, size_t size)
+ {
+-    void              *p;
+-    ngx_uint_t         n;
+-    ngx_pool_large_t  *large;
+-
+-    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) {
+-        ngx_free(p);
+-        return NULL;
+-    }
++    return ngx_malloc(pool, size);
++}
+ 
+-    large->alloc = p;
+-    large->next = pool->large;
+-    pool->large = large;
+ 
+-    return p;
++void *
++ngx_pnalloc(ngx_pool_t *pool, size_t size)
++{
++    return ngx_malloc(pool, size);
+ }
+ 
+ 
+@@ -256,38 +152,48 @@
+ 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 -urx '*~' -x '*.swp' nginx-1.2.7/src/core/ngx_palloc.h nginx-1.2.7-patched/src/core/ngx_palloc.h
+--- nginx-1.2.7/src/core/ngx_palloc.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.7-patched/src/core/ngx_palloc.h	2012-06-21 10:35:47.463405863 +0800
+@@ -38,28 +38,21 @@
+ };
+ 
+ 
+-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.2.7-run_posted_requests_in_resolver.patch

@@ -0,0 +1,46 @@
+diff -ruNp nginx-1.2.7/src/http/ngx_http_upstream.c nginx-1.2.7_zls/src/http/ngx_http_upstream.c
+--- nginx-1.2.7/src/http/ngx_http_upstream.c	2013-02-18 23:08:46.000000000 +0800
++++ nginx-1.2.7_zls/src/http/ngx_http_upstream.c	2013-03-13 00:01:01.490582380 +0800
+@@ -878,11 +878,13 @@ ngx_http_upstream_cache_send(ngx_http_re
+ static void
+ ngx_http_upstream_resolve_handler(ngx_resolver_ctx_t *ctx)
+ {
++    ngx_connection_t              *c;
+     ngx_http_request_t            *r;
+     ngx_http_upstream_t           *u;
+     ngx_http_upstream_resolved_t  *ur;
+ 
+     r = ctx->data;
++    c = r->connection;
+ 
+     u = r->upstream;
+     ur = u->resolved;
+@@ -894,7 +896,8 @@ ngx_http_upstream_resolve_handler(ngx_re
+                       ngx_resolver_strerror(ctx->state));
+ 
+         ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
+-        return;
++
++        goto posted_requests;
+     }
+ 
+     ur->naddrs = ctx->naddrs;
+@@ -919,13 +922,17 @@ ngx_http_upstream_resolve_handler(ngx_re
+     if (ngx_http_upstream_create_round_robin_peer(r, ur) != NGX_OK) {
+         ngx_http_upstream_finalize_request(r, u,
+                                            NGX_HTTP_INTERNAL_SERVER_ERROR);
+-        return;
++        goto posted_requests;
+     }
+ 
+     ngx_resolve_name_done(ctx);
+     ur->ctx = NULL;
+ 
+     ngx_http_upstream_connect(r, u);
++
++posted_requests:
++
++    ngx_http_run_posted_requests(c);
+ }
+ 
+ 

patches/nginx-1.2.7-server_header.patch

@@ -0,0 +1,26 @@
+diff -ur lz-nginx-1.2.7/nginx-1.2.7/src/core/nginx.h lz-nginx-1.2.7-patched/nginx-1.2.7/src/core/nginx.h
+--- lz-nginx-1.2.7/nginx-1.2.7/src/core/nginx.h	2010-02-12 17:31:01.000000000 +0800
++++ lz-nginx-1.2.7-patched/nginx-1.2.7/src/core/nginx.h	2010-03-30 10:52:13.240702627 +0800
+@@ -10,7 +10,7 @@
+ 
+ #define nginx_version         1002007
+ #define NGINX_VERSION      "1.2.7"
+-#define NGINX_VER          "nginx/" NGINX_VERSION
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
+ 
+ #define NGINX_VAR          "NGINX"
+ #define NGX_OLDPID_EXT     ".oldbin"
+Only in lz-nginx-1.2.7-patched/nginx-1.2.7/src/core: nginx.h.orig
+Only in lz-nginx-1.2.7-patched/nginx-1.2.7/src/core: nginx.h.rej
+diff -ur lz-nginx-1.2.7/nginx-1.2.7/src/http/ngx_http_header_filter_module.c lz-nginx-1.2.7-patched/nginx-1.2.7/src/http/ngx_http_header_filter_module.c
+--- lz-nginx-1.2.7/nginx-1.2.7/src/http/ngx_http_header_filter_module.c	2010-03-03 23:14:04.000000000 +0800
++++ lz-nginx-1.2.7-patched/nginx-1.2.7/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: ngx_openresty" CRLF;
+ static char ngx_http_server_full_string[] = "Server: " NGINX_VER CRLF;
+ 
+ 

patches/nginx-1.2.7-slab_alloc_no_memory_as_info.patch

@@ -0,0 +1,11 @@
+--- nginx-1.2.7/src/core/ngx_slab.c	2012-09-24 11:34:04.000000000 -0700
++++ nginx-1.2.7-patched/src/core/ngx_slab.c	2012-12-05 20:47:07.296694952 -0800
+@@ -657,7 +657,7 @@ ngx_slab_alloc_pages(ngx_slab_pool_t *po
+         }
+     }
+ 
+-    ngx_slab_error(pool, NGX_LOG_CRIT, "ngx_slab_alloc() failed: no memory");
++    ngx_slab_error(pool, NGX_LOG_INFO, "ngx_slab_alloc() failed: no memory");
+ 
+     return NULL;
+ }

patches/nginx-1.2.7-upstream_pipelining.patch

@@ -0,0 +1,40 @@
+diff -rudp nginx-1.2.7/src/http/ngx_http_upstream.c nginx-1.2.7-patched/src/http/ngx_http_upstream.c
+--- nginx-1.2.7/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.2.7-patched/src/http/ngx_http_upstream.c	2012-12-05 14:46:41.741173058 -0800
+@@ -1216,6 +1216,7 @@ ngx_http_upstream_connect(ngx_http_reque
+     }
+ 
+     u->request_sent = 0;
++    u->request_all_sent = 0;
+ 
+     if (rc == NGX_AGAIN) {
+         ngx_add_timer(c->write, u->conf->connect_timeout);
+@@ -1418,6 +1419,8 @@ ngx_http_upstream_send_request(ngx_http_
+ 
+     /* rc == NGX_OK */
+ 
++    u->request_all_sent = 1;
++
+     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
+         if (ngx_tcp_push(c->fd) == NGX_ERROR) {
+             ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
+@@ -1484,7 +1487,7 @@ ngx_http_upstream_send_request_handler(n
+ 
+ #endif
+ 
+-    if (u->header_sent) {
++    if (u->request_all_sent) {
+         u->write_event_handler = ngx_http_upstream_dummy_handler;
+ 
+         (void) ngx_handle_write_event(c->write, 0);
+diff -rudp nginx-1.2.7/src/http/ngx_http_upstream.h nginx-1.2.7-patched/src/http/ngx_http_upstream.h
+--- nginx-1.2.7/src/http/ngx_http_upstream.h	2012-02-13 03:01:58.000000000 -0800
++++ nginx-1.2.7-patched/src/http/ngx_http_upstream.h	2012-12-05 14:41:09.763514741 -0800
+@@ -324,6 +324,7 @@ struct ngx_http_upstream_s {
+     unsigned                         keepalive:1;
+ 
+     unsigned                         request_sent:1;
++    unsigned                         request_all_sent:1;
+     unsigned                         header_sent:1;
+ };
+ 

patches/nginx-1.2.7-upstream_truncation.patch

@@ -0,0 +1,149 @@
+diff --exclude '*~' --exclude '*.swp' -urp nginx-1.2.7/src/http/modules/ngx_http_scgi_module.c nginx-1.2.7-patched/src/http/modules/ngx_http_scgi_module.c
+--- nginx-1.2.7/src/http/modules/ngx_http_scgi_module.c	2013-02-09 19:08:42.000000000 -0800
++++ nginx-1.2.7-patched/src/http/modules/ngx_http_scgi_module.c	2013-04-07 12:09:55.900492634 -0700
+@@ -39,6 +39,7 @@ static ngx_int_t ngx_http_scgi_process_s
+ static ngx_int_t ngx_http_scgi_process_header(ngx_http_request_t *r);
+ static void ngx_http_scgi_abort_request(ngx_http_request_t *r);
+ static void ngx_http_scgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc);
++static ngx_int_t ngx_http_scgi_input_filter_init(void *data);
+ 
+ static void *ngx_http_scgi_create_loc_conf(ngx_conf_t *cf);
+ static char *ngx_http_scgi_merge_loc_conf(ngx_conf_t *cf, void *parent,
+@@ -446,6 +447,8 @@ ngx_http_scgi_handler(ngx_http_request_t
+     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
+     u->pipe->input_ctx = r;
+ 
++    u->input_filter_init = ngx_http_scgi_input_filter_init;
++
+     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);
+ 
+     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
+@@ -1046,6 +1049,17 @@ ngx_http_scgi_finalize_request(ngx_http_
+ }
+ 
+ 
++static ngx_int_t
++ngx_http_scgi_input_filter_init(void *data)
++{
++    ngx_http_request_t    *r = data;
++
++    r->upstream->length = -1;
++
++    return NGX_OK;
++}
++
++
+ static void *
+ ngx_http_scgi_create_loc_conf(ngx_conf_t *cf)
+ {
+diff --exclude '*~' --exclude '*.swp' -urp nginx-1.2.7/src/http/modules/ngx_http_uwsgi_module.c nginx-1.2.7-patched/src/http/modules/ngx_http_uwsgi_module.c
+--- nginx-1.2.7/src/http/modules/ngx_http_uwsgi_module.c	2013-02-09 19:08:42.000000000 -0800
++++ nginx-1.2.7-patched/src/http/modules/ngx_http_uwsgi_module.c	2013-04-07 11:58:24.546915778 -0700
+@@ -46,6 +46,7 @@ static ngx_int_t ngx_http_uwsgi_process_
+ static void ngx_http_uwsgi_abort_request(ngx_http_request_t *r);
+ static void ngx_http_uwsgi_finalize_request(ngx_http_request_t *r,
+     ngx_int_t rc);
++static ngx_int_t ngx_http_uwsgi_input_filter_init(void *data);
+ 
+ static void *ngx_http_uwsgi_create_loc_conf(ngx_conf_t *cf);
+ static char *ngx_http_uwsgi_merge_loc_conf(ngx_conf_t *cf, void *parent,
+@@ -479,6 +480,8 @@ ngx_http_uwsgi_handler(ngx_http_request_
+     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
+     u->pipe->input_ctx = r;
+ 
++    u->input_filter_init = ngx_http_uwsgi_input_filter_init;
++
+     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);
+ 
+     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
+@@ -1086,6 +1089,17 @@ ngx_http_uwsgi_finalize_request(ngx_http
+ }
+ 
+ 
++static ngx_int_t
++ngx_http_uwsgi_input_filter_init(void *data)
++{
++    ngx_http_request_t    *r = data;
++
++    r->upstream->length = -1;
++
++    return NGX_OK;
++}
++
++
+ static void *
+ ngx_http_uwsgi_create_loc_conf(ngx_conf_t *cf)
+ {
+diff --exclude '*~' --exclude '*.swp' -urp nginx-1.2.7/src/http/ngx_http_upstream.c nginx-1.2.7-patched/src/http/ngx_http_upstream.c
+--- nginx-1.2.7/src/http/ngx_http_upstream.c	2013-02-11 06:39:49.000000000 -0800
++++ nginx-1.2.7-patched/src/http/ngx_http_upstream.c	2013-04-08 16:37:48.326752696 -0700
+@@ -2399,7 +2399,7 @@ ngx_http_upstream_process_non_buffered_u
+ 
+     if (c->read->timedout) {
+         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
+-        ngx_http_upstream_finalize_request(r, u, 0);
++        ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
+         return;
+     }
+ 
+@@ -2446,13 +2446,20 @@ ngx_http_upstream_process_non_buffered_r
+             if (u->busy_bufs == NULL) {
+ 
+                 if (u->length == 0
+-                    || upstream->read->eof
+-                    || upstream->read->error)
++                    || (upstream->read->eof
++                        && u->length == -1
++                        && u->pipe
++                        && u->pipe->length <= 0))
+                 {
+                     ngx_http_upstream_finalize_request(r, u, 0);
+                     return;
+                 }
+ 
++                if (upstream->read->eof || upstream->read->error) {
++                    ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++                    return;
++                }
++
+                 b->pos = b->start;
+                 b->last = b->start;
+             }
+@@ -2720,7 +2727,9 @@ ngx_http_upstream_process_request(ngx_ht
+ 
+ #endif
+ 
+-        if (p->upstream_done || p->upstream_eof || p->upstream_error) {
++        if (p->upstream_done
++            || (p->upstream_eof && u->length == -1 && p->length <= 0))
++        {
+             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                            "http upstream exit: %p", p->out);
+ #if 0
+@@ -2729,6 +2738,14 @@ ngx_http_upstream_process_request(ngx_ht
+             ngx_http_upstream_finalize_request(r, u, 0);
+             return;
+         }
++
++        if (p->upstream_eof || p->upstream_error) {
++            ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
++                           "http upstream exit: %p", p->out);
++
++            ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++            return;
++       }
+     }
+ 
+     if (p->downstream_error) {
+@@ -3087,9 +3104,9 @@ ngx_http_upstream_finalize_request(ngx_h
+ 
+     if (u->header_sent
+         && rc != NGX_HTTP_REQUEST_TIME_OUT
+-        && (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
++        && rc >= NGX_HTTP_SPECIAL_RESPONSE)
+     {
+-        rc = 0;
++        rc = NGX_ERROR;
+     }
+ 
+     if (rc == NGX_DECLINED) {

patches/nginx-1.2.8-channel-uninit-params.patch

@@ -0,0 +1,42 @@
+diff -urp nginx-1.2.8/src/os/unix/ngx_channel.c nginx-1.2.8-patched/src/os/unix/ngx_channel.c
+--- nginx-1.2.8/src/os/unix/ngx_channel.c	2012-01-18 07:07:43.000000000 -0800
++++ nginx-1.2.8-patched/src/os/unix/ngx_channel.c	2012-09-17 11:33:09.215394217 -0700
+@@ -31,6 +31,8 @@ ngx_write_channel(ngx_socket_t s, ngx_ch
+         msg.msg_controllen = 0;
+ 
+     } else {
++        ngx_memzero(&cmsg, sizeof(cmsg));
++
+         msg.msg_control = (caddr_t) &cmsg;
+         msg.msg_controllen = sizeof(cmsg);
+ 
+diff -urp nginx-1.2.8/src/os/unix/ngx_process_cycle.c nginx-1.2.8-patched/src/os/unix/ngx_process_cycle.c
+--- nginx-1.2.8/src/os/unix/ngx_process_cycle.c	2012-07-02 09:23:14.000000000 -0700
++++ nginx-1.2.8-patched/src/os/unix/ngx_process_cycle.c	2012-09-17 11:33:09.214394215 -0700
+@@ -356,6 +356,8 @@ ngx_start_worker_processes(ngx_cycle_t *
+ 
+     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_OPEN_CHANNEL;
+ 
+     for (i = 0; i < n; i++) {
+@@ -463,6 +465,8 @@ ngx_signal_worker_processes(ngx_cycle_t
+     ngx_err_t      err;
+     ngx_channel_t  ch;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+ #if (NGX_BROKEN_SCM_RIGHTS)
+ 
+     ch.command = 0;
+@@ -564,6 +568,8 @@ ngx_reap_children(ngx_cycle_t *cycle)
+     ngx_channel_t     ch;
+     ngx_core_conf_t  *ccf;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_CLOSE_CHANNEL;
+     ch.fd = -1;
+ 

patches/nginx-1.2.8-cve-2013-2070.patch

@@ -0,0 +1,13 @@
+--- src/http/modules/ngx_http_proxy_module.c
++++ src/http/modules/ngx_http_proxy_module.c
+@@ -1865,6 +1865,10 @@ data:
+ 
+     }
+ 
++    if (ctx->size < 0 || ctx->length < 0) {
++        goto invalid;
++    }
++
+     return rc;
+ 
+ done:

patches/nginx-1.2.8-invalid_referer_hash.patch

@@ -0,0 +1,12 @@
+--- nginx-1.2.8/src/http/modules/ngx_http_referer_module.c	2013-05-06 03:27:10.000000000 -0700
++++ nginx-1.2.8-patched/src/http/modules/ngx_http_referer_module.c	2013-05-21 16:04:49.340286168 -0700
+@@ -396,8 +396,7 @@ ngx_http_valid_referers(ngx_conf_t *cf,
+ 
+     ngx_str_set(&name, "invalid_referer");
+ 
+-    var = ngx_http_add_variable(cf, &name,
+-                                NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_NOHASH);
++    var = ngx_http_add_variable(cf, &name, NGX_HTTP_VAR_CHANGEABLE);
+     if (var == NULL) {
+         return NGX_CONF_ERROR;
+     }

patches/nginx-1.2.8-location_if_inherits_proxy.patch

@@ -0,0 +1,15 @@
+--- nginx-1.2.8/src/http/modules/ngx_http_proxy_module.c	2012-04-23 18:40:01.000000000 +0800
++++ nginx-1.2.8-patched/src/http/modules/ngx_http_proxy_module.c	2012-06-24 12:48:57.289834450 +0800
+@@ -3023,8 +3023,10 @@
+ 
+     if (conf->upstream.upstream || conf->proxy_lengths) {
+         clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
+-        if (clcf->handler == NULL && clcf->lmt_excpt) {
+-            clcf->handler = ngx_http_proxy_handler;
++        if (clcf->handler == NULL) {
++            if (clcf->lmt_excpt) {
++                clcf->handler = ngx_http_proxy_handler;
++            }
+             conf->location = prev->location;
+         }
+     }

patches/nginx-1.2.8-log_escape_non_ascii.patch

@@ -0,0 +1,115 @@
+--- nginx-1.2.8/src/http/modules/ngx_http_log_module.c	2011-11-01 21:24:50.000000000 +0800
++++ nginx-1.2.8-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.2.8-no_Werror.patch

@@ -0,0 +1,24 @@
+diff -ur nginx-1.2.8/auto/cc/gcc nginx-1.2.8-patched/auto/cc/gcc
+--- nginx-1.2.8/auto/cc/gcc	2011-06-27 19:53:00.205737804 +0800
++++ nginx-1.2.8-patched/auto/cc/gcc	2011-06-27 19:53:13.837741087 +0800
+@@ -169,7 +169,7 @@
+ 
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"
+diff -ur nginx-1.2.8/auto/cc/icc nginx-1.2.8-patched/auto/cc/icc
+--- nginx-1.2.8/auto/cc/icc	2011-06-27 19:52:56.370157068 +0800
++++ nginx-1.2.8-patched/auto/cc/icc	2011-06-27 19:53:19.508916811 +0800
+@@ -139,7 +139,7 @@
+ esac
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"

patches/nginx-1.2.8-no_error_pages.patch

@@ -0,0 +1,90 @@
+--- nginx-1.2.8/src/http/ngx_http_core_module.c	2010-12-14 18:38:42.000000000 +0800
++++ nginx-1.2.8-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.2.8-no_pool.patch

@@ -0,0 +1,609 @@
+diff -ur nginx-1.2.8/src/core/nginx.h nginx-1.2.8-patched/src/core/nginx.h
+--- nginx-1.2.8/src/core/nginx.h	2011-08-29 17:30:22.000000000 +0800
++++ nginx-1.2.8-patched/src/core/nginx.h	2011-09-13 12:11:03.135622101 +0800
+@@ -10,7 +10,7 @@
+ 
+ 
+ #define nginx_version      1002008
+ #define NGINX_VERSION      "1.2.8"
+-#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown (no pool)"
+ 
+ #define NGINX_VAR          "NGINX"
+diff -urx '*~' -x '*.swp' nginx-1.2.8/src/core/ngx_array.c nginx-1.2.8-patched/src/core/ngx_array.c
+--- nginx-1.2.8/src/core/ngx_array.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.8-patched/src/core/ngx_array.c	2012-06-20 23:10:36.870722387 +0800
+@@ -28,6 +28,7 @@
+     a->size = size;
+     a->nalloc = n;
+     a->pool = p;
++    a->old_elts = NULL;
+ 
+     return a;
+ }
+@@ -36,26 +37,30 @@
+ 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) {
+ 
+@@ -65,29 +70,27 @@
+ 
+         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++;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            new = ngx_palloc(p, 2 * size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, size);
+-            a->elts = new;
+-            a->nalloc *= 2;
++        /* allocate a new array */
++
++        new = ngx_palloc(p, 2 * size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, size);
++
++        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;
+@@ -101,11 +104,10 @@
+ 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) {
+ 
+@@ -113,31 +115,27 @@
+ 
+         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
+-             */
+-
+-            p->d.last += size;
+-            a->nalloc += n;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
+-
+-            new = ngx_palloc(p, nalloc * a->size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, a->nelts * a->size);
+-            a->elts = new;
+-            a->nalloc = nalloc;
++        nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
++
++        new = ngx_palloc(p, nalloc * a->size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, a->nelts * a->size);
++
++        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 = nalloc;
+     }
+ 
+     elt = (u_char *) a->elts + a->size * a->nelts;
+diff -urx '*~' -x '*.swp' nginx-1.2.8/src/core/ngx_array.h nginx-1.2.8-patched/src/core/ngx_array.h
+--- nginx-1.2.8/src/core/ngx_array.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.8-patched/src/core/ngx_array.h	2012-06-20 23:25:38.800624960 +0800
+@@ -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;
++};
++
++
+ struct ngx_array_s {
+     void        *elts;
+     ngx_uint_t   nelts;
+     size_t       size;
+     ngx_uint_t   nalloc;
+     ngx_pool_t  *pool;
++
++    ngx_array_link_t *old_elts;
+ };
+ 
+ 
+@@ -40,6 +51,7 @@
+     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 -urx '*~' -x '*.swp' nginx-1.2.8/src/core/ngx_palloc.c nginx-1.2.8-patched/src/core/ngx_palloc.c
+--- nginx-1.2.8/src/core/ngx_palloc.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.8-patched/src/core/ngx_palloc.c	2012-06-20 22:56:30.148073066 +0800
+@@ -9,32 +9,23 @@
+ #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);
+-
+-
+ 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 +35,7 @@
+ 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 +46,9 @@
+         }
+     }
+ 
+-    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 +58,9 @@
+      * 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,172 +69,82 @@
+ 
+ #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;
+ 
+-void
+-ngx_reset_pool(ngx_pool_t *pool)
+-{
+-    ngx_pool_t        *p;
+-    ngx_pool_large_t  *l;
+-
+-    for (l = pool->large; l; l = l->next) {
+-        if (l->alloc) {
+-            ngx_free(l->alloc);
+-        }
+-    }
+-
+-    pool->large = NULL;
+-
+-    for (p = pool; p; p = p->d.next) {
+-        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
+-    }
++    ngx_free(pool);
+ }
+ 
+ 
+-void *
+-ngx_palloc(ngx_pool_t *pool, size_t size)
++void
++ngx_reset_pool(ngx_pool_t *pool)
+ {
+-    u_char      *m;
+-    ngx_pool_t  *p;
+-
+-    if (size <= pool->max) {
++    ngx_pool_data_t     *d, *n;
++    ngx_pool_data_t     *saved = NULL;
+ 
+-        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;
++    if (pool->d) {
++        for (d = pool->d, n = d->next; ; d = n, n = n->next) {
++            if (d->alloc == pool->log) {
++                saved = d;
++                continue;
+             }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
+-    }
+-
+-    return ngx_palloc_large(pool, size);
+-}
+-
++            ngx_free(d->alloc);
++            ngx_free(d);
+ 
+-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;
++            if (n == NULL) {
++                break;
+             }
++        }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
++        pool->d = saved;
+     }
+-
+-    return ngx_palloc_large(pool, size);
+ }
+ 
+ 
+-static void *
+-ngx_palloc_block(ngx_pool_t *pool, size_t size)
++void *
++ngx_malloc(ngx_pool_t *pool, size_t size)
+ {
+-    u_char      *m;
+-    size_t       psize;
+-    ngx_pool_t  *p, *new, *current;
++    ngx_pool_data_t     *d;
++    void                *p;
+ 
+-    psize = (size_t) (pool->d.end - (u_char *) pool);
+-
+-    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
+-    if (m == NULL) {
++    p = ngx_alloc(size, pool->log);
++    if (p == 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;
+-
+-    current = pool->current;
+-
+-    for (p = current; p->d.next; p = p->d.next) {
+-        if (p->d.failed++ > 4) {
+-            current = p->d.next;
+-        }
++    d = ngx_alloc(sizeof(ngx_pool_data_t), pool->log);
++    if (d == NULL){
++        ngx_free(p);
++        return NULL;
+     }
+ 
+-    p->d.next = new;
+-
+-    pool->current = current ? current : new;
+-
+-    return m;
++    d->alloc = p;
++    d->next = pool->d;
++    pool->d = d;
++    return p;
+ }
+ 
+ 
+-static void *
+-ngx_palloc_large(ngx_pool_t *pool, size_t size)
++void *
++ngx_palloc(ngx_pool_t *pool, size_t size)
+ {
+-    void              *p;
+-    ngx_uint_t         n;
+-    ngx_pool_large_t  *large;
+-
+-    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) {
+-        ngx_free(p);
+-        return NULL;
+-    }
++    return ngx_malloc(pool, size);
++}
+ 
+-    large->alloc = p;
+-    large->next = pool->large;
+-    pool->large = large;
+ 
+-    return p;
++void *
++ngx_pnalloc(ngx_pool_t *pool, size_t size)
++{
++    return ngx_malloc(pool, size);
+ }
+ 
+ 
+@@ -256,38 +152,48 @@
+ 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 -urx '*~' -x '*.swp' nginx-1.2.8/src/core/ngx_palloc.h nginx-1.2.8-patched/src/core/ngx_palloc.h
+--- nginx-1.2.8/src/core/ngx_palloc.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.2.8-patched/src/core/ngx_palloc.h	2012-06-21 10:35:47.463405863 +0800
+@@ -38,28 +38,21 @@
+ };
+ 
+ 
+-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.2.8-server_header.patch

@@ -0,0 +1,26 @@
+diff -ur lz-nginx-1.2.8/nginx-1.2.8/src/core/nginx.h lz-nginx-1.2.8-patched/nginx-1.2.8/src/core/nginx.h
+--- lz-nginx-1.2.8/nginx-1.2.8/src/core/nginx.h	2010-02-12 17:31:01.000000000 +0800
++++ lz-nginx-1.2.8-patched/nginx-1.2.8/src/core/nginx.h	2010-03-30 10:52:13.240702627 +0800
+@@ -10,7 +10,7 @@
+ 
+ #define nginx_version         1002008
+ #define NGINX_VERSION      "1.2.8"
+-#define NGINX_VER          "nginx/" NGINX_VERSION
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
+ 
+ #define NGINX_VAR          "NGINX"
+ #define NGX_OLDPID_EXT     ".oldbin"
+Only in lz-nginx-1.2.8-patched/nginx-1.2.8/src/core: nginx.h.orig
+Only in lz-nginx-1.2.8-patched/nginx-1.2.8/src/core: nginx.h.rej
+diff -ur lz-nginx-1.2.8/nginx-1.2.8/src/http/ngx_http_header_filter_module.c lz-nginx-1.2.8-patched/nginx-1.2.8/src/http/ngx_http_header_filter_module.c
+--- lz-nginx-1.2.8/nginx-1.2.8/src/http/ngx_http_header_filter_module.c	2010-03-03 23:14:04.000000000 +0800
++++ lz-nginx-1.2.8-patched/nginx-1.2.8/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: ngx_openresty" CRLF;
+ static char ngx_http_server_full_string[] = "Server: " NGINX_VER CRLF;
+ 
+ 

patches/nginx-1.2.8-slab_alloc_no_memory_as_info.patch

@@ -0,0 +1,11 @@
+--- nginx-1.2.8/src/core/ngx_slab.c	2012-09-24 11:34:04.000000000 -0700
++++ nginx-1.2.8-patched/src/core/ngx_slab.c	2012-12-05 20:47:07.296694952 -0800
+@@ -657,7 +657,7 @@ ngx_slab_alloc_pages(ngx_slab_pool_t *po
+         }
+     }
+ 
+-    ngx_slab_error(pool, NGX_LOG_CRIT, "ngx_slab_alloc() failed: no memory");
++    ngx_slab_error(pool, NGX_LOG_INFO, "ngx_slab_alloc() failed: no memory");
+ 
+     return NULL;
+ }

patches/nginx-1.2.8-upstream_pipelining.patch

@@ -0,0 +1,40 @@
+diff -rudp nginx-1.2.8/src/http/ngx_http_upstream.c nginx-1.2.8-patched/src/http/ngx_http_upstream.c
+--- nginx-1.2.8/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.2.8-patched/src/http/ngx_http_upstream.c	2012-12-05 14:46:41.741173058 -0800
+@@ -1216,6 +1216,7 @@ ngx_http_upstream_connect(ngx_http_reque
+     }
+ 
+     u->request_sent = 0;
++    u->request_all_sent = 0;
+ 
+     if (rc == NGX_AGAIN) {
+         ngx_add_timer(c->write, u->conf->connect_timeout);
+@@ -1418,6 +1419,8 @@ ngx_http_upstream_send_request(ngx_http_
+ 
+     /* rc == NGX_OK */
+ 
++    u->request_all_sent = 1;
++
+     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
+         if (ngx_tcp_push(c->fd) == NGX_ERROR) {
+             ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
+@@ -1484,7 +1487,7 @@ ngx_http_upstream_send_request_handler(n
+ 
+ #endif
+ 
+-    if (u->header_sent) {
++    if (u->request_all_sent) {
+         u->write_event_handler = ngx_http_upstream_dummy_handler;
+ 
+         (void) ngx_handle_write_event(c->write, 0);
+diff -rudp nginx-1.2.8/src/http/ngx_http_upstream.h nginx-1.2.8-patched/src/http/ngx_http_upstream.h
+--- nginx-1.2.8/src/http/ngx_http_upstream.h	2012-02-13 03:01:58.000000000 -0800
++++ nginx-1.2.8-patched/src/http/ngx_http_upstream.h	2012-12-05 14:41:09.763514741 -0800
+@@ -324,6 +324,7 @@ struct ngx_http_upstream_s {
+     unsigned                         keepalive:1;
+ 
+     unsigned                         request_sent:1;
++    unsigned                         request_all_sent:1;
+     unsigned                         header_sent:1;
+ };
+ 

patches/nginx-1.2.8-upstream_truncation.patch

@@ -0,0 +1,149 @@
+diff --exclude '*~' --exclude '*.swp' -urp nginx-1.2.8/src/http/modules/ngx_http_scgi_module.c nginx-1.2.8-patched/src/http/modules/ngx_http_scgi_module.c
+--- nginx-1.2.8/src/http/modules/ngx_http_scgi_module.c	2013-02-09 19:08:42.000000000 -0800
++++ nginx-1.2.8-patched/src/http/modules/ngx_http_scgi_module.c	2013-04-07 12:09:55.900492634 -0700
+@@ -39,6 +39,7 @@ static ngx_int_t ngx_http_scgi_process_s
+ static ngx_int_t ngx_http_scgi_process_header(ngx_http_request_t *r);
+ static void ngx_http_scgi_abort_request(ngx_http_request_t *r);
+ static void ngx_http_scgi_finalize_request(ngx_http_request_t *r, ngx_int_t rc);
++static ngx_int_t ngx_http_scgi_input_filter_init(void *data);
+ 
+ static void *ngx_http_scgi_create_loc_conf(ngx_conf_t *cf);
+ static char *ngx_http_scgi_merge_loc_conf(ngx_conf_t *cf, void *parent,
+@@ -446,6 +447,8 @@ ngx_http_scgi_handler(ngx_http_request_t
+     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
+     u->pipe->input_ctx = r;
+ 
++    u->input_filter_init = ngx_http_scgi_input_filter_init;
++
+     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);
+ 
+     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
+@@ -1046,6 +1049,17 @@ ngx_http_scgi_finalize_request(ngx_http_
+ }
+ 
+ 
++static ngx_int_t
++ngx_http_scgi_input_filter_init(void *data)
++{
++    ngx_http_request_t    *r = data;
++
++    r->upstream->length = -1;
++
++    return NGX_OK;
++}
++
++
+ static void *
+ ngx_http_scgi_create_loc_conf(ngx_conf_t *cf)
+ {
+diff --exclude '*~' --exclude '*.swp' -urp nginx-1.2.8/src/http/modules/ngx_http_uwsgi_module.c nginx-1.2.8-patched/src/http/modules/ngx_http_uwsgi_module.c
+--- nginx-1.2.8/src/http/modules/ngx_http_uwsgi_module.c	2013-02-09 19:08:42.000000000 -0800
++++ nginx-1.2.8-patched/src/http/modules/ngx_http_uwsgi_module.c	2013-04-07 11:58:24.546915778 -0700
+@@ -46,6 +46,7 @@ static ngx_int_t ngx_http_uwsgi_process_
+ static void ngx_http_uwsgi_abort_request(ngx_http_request_t *r);
+ static void ngx_http_uwsgi_finalize_request(ngx_http_request_t *r,
+     ngx_int_t rc);
++static ngx_int_t ngx_http_uwsgi_input_filter_init(void *data);
+ 
+ static void *ngx_http_uwsgi_create_loc_conf(ngx_conf_t *cf);
+ static char *ngx_http_uwsgi_merge_loc_conf(ngx_conf_t *cf, void *parent,
+@@ -479,6 +480,8 @@ ngx_http_uwsgi_handler(ngx_http_request_
+     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
+     u->pipe->input_ctx = r;
+ 
++    u->input_filter_init = ngx_http_uwsgi_input_filter_init;
++
+     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);
+ 
+     if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
+@@ -1086,6 +1089,17 @@ ngx_http_uwsgi_finalize_request(ngx_http
+ }
+ 
+ 
++static ngx_int_t
++ngx_http_uwsgi_input_filter_init(void *data)
++{
++    ngx_http_request_t    *r = data;
++
++    r->upstream->length = -1;
++
++    return NGX_OK;
++}
++
++
+ static void *
+ ngx_http_uwsgi_create_loc_conf(ngx_conf_t *cf)
+ {
+diff --exclude '*~' --exclude '*.swp' -urp nginx-1.2.8/src/http/ngx_http_upstream.c nginx-1.2.8-patched/src/http/ngx_http_upstream.c
+--- nginx-1.2.8/src/http/ngx_http_upstream.c	2013-02-11 06:39:49.000000000 -0800
++++ nginx-1.2.8-patched/src/http/ngx_http_upstream.c	2013-04-08 16:37:48.326752696 -0700
+@@ -2399,7 +2399,7 @@ ngx_http_upstream_process_non_buffered_u
+ 
+     if (c->read->timedout) {
+         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
+-        ngx_http_upstream_finalize_request(r, u, 0);
++        ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
+         return;
+     }
+ 
+@@ -2446,13 +2446,20 @@ ngx_http_upstream_process_non_buffered_r
+             if (u->busy_bufs == NULL) {
+ 
+                 if (u->length == 0
+-                    || upstream->read->eof
+-                    || upstream->read->error)
++                    || (upstream->read->eof
++                        && u->length == -1
++                        && u->pipe
++                        && u->pipe->length <= 0))
+                 {
+                     ngx_http_upstream_finalize_request(r, u, 0);
+                     return;
+                 }
+ 
++                if (upstream->read->eof || upstream->read->error) {
++                    ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++                    return;
++                }
++
+                 b->pos = b->start;
+                 b->last = b->start;
+             }
+@@ -2720,7 +2727,9 @@ ngx_http_upstream_process_request(ngx_ht
+ 
+ #endif
+ 
+-        if (p->upstream_done || p->upstream_eof || p->upstream_error) {
++        if (p->upstream_done
++            || (p->upstream_eof && u->length == -1 && p->length <= 0))
++        {
+             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                            "http upstream exit: %p", p->out);
+ #if 0
+@@ -2729,6 +2738,14 @@ ngx_http_upstream_process_request(ngx_ht
+             ngx_http_upstream_finalize_request(r, u, 0);
+             return;
+         }
++
++        if (p->upstream_eof || p->upstream_error) {
++            ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
++                           "http upstream exit: %p", p->out);
++
++            ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++            return;
++       }
+     }
+ 
+     if (p->downstream_error) {
+@@ -3087,9 +3104,9 @@ ngx_http_upstream_finalize_request(ngx_h
+ 
+     if (u->header_sent
+         && rc != NGX_HTTP_REQUEST_TIME_OUT
+-        && (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
++        && rc >= NGX_HTTP_SPECIAL_RESPONSE)
+     {
+-        rc = 0;
++        rc = NGX_ERROR;
+     }
+ 
+     if (rc == NGX_DECLINED) {

patches/nginx-1.3.11-channel-uninit-params.patch

@@ -0,0 +1,42 @@
+diff -urp nginx-1.3.11/src/os/unix/ngx_channel.c nginx-1.3.11-patched/src/os/unix/ngx_channel.c
+--- nginx-1.3.11/src/os/unix/ngx_channel.c	2012-01-18 07:07:43.000000000 -0800
++++ nginx-1.3.11-patched/src/os/unix/ngx_channel.c	2012-09-17 11:33:09.215394217 -0700
+@@ -31,6 +31,8 @@ ngx_write_channel(ngx_socket_t s, ngx_ch
+         msg.msg_controllen = 0;
+ 
+     } else {
++        ngx_memzero(&cmsg, sizeof(cmsg));
++
+         msg.msg_control = (caddr_t) &cmsg;
+         msg.msg_controllen = sizeof(cmsg);
+ 
+diff -urp nginx-1.3.11/src/os/unix/ngx_process_cycle.c nginx-1.3.11-patched/src/os/unix/ngx_process_cycle.c
+--- nginx-1.3.11/src/os/unix/ngx_process_cycle.c	2012-07-02 09:23:14.000000000 -0700
++++ nginx-1.3.11-patched/src/os/unix/ngx_process_cycle.c	2012-09-17 11:33:09.214394215 -0700
+@@ -356,6 +356,8 @@ ngx_start_worker_processes(ngx_cycle_t *
+ 
+     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_OPEN_CHANNEL;
+ 
+     for (i = 0; i < n; i++) {
+@@ -463,6 +465,8 @@ ngx_signal_worker_processes(ngx_cycle_t
+     ngx_err_t      err;
+     ngx_channel_t  ch;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+ #if (NGX_BROKEN_SCM_RIGHTS)
+ 
+     ch.command = 0;
+@@ -564,6 +568,8 @@ ngx_reap_children(ngx_cycle_t *cycle)
+     ngx_channel_t     ch;
+     ngx_core_conf_t  *ccf;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_CLOSE_CHANNEL;
+     ch.fd = -1;
+ 

patches/nginx-1.3.11-location_if_inherits_proxy.patch

@@ -0,0 +1,15 @@
+--- nginx-1.3.11/src/http/modules/ngx_http_proxy_module.c	2012-04-23 18:40:01.000000000 +0800
++++ nginx-1.3.11-patched/src/http/modules/ngx_http_proxy_module.c	2012-06-24 12:48:57.289834450 +0800
+@@ -3023,8 +3023,10 @@
+ 
+     if (conf->upstream.upstream || conf->proxy_lengths) {
+         clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
+-        if (clcf->handler == NULL && clcf->lmt_excpt) {
+-            clcf->handler = ngx_http_proxy_handler;
++        if (clcf->handler == NULL) {
++            if (clcf->lmt_excpt) {
++                clcf->handler = ngx_http_proxy_handler;
++            }
+             conf->location = prev->location;
+         }
+     }

patches/nginx-1.3.11-log_escape_non_ascii.patch

@@ -0,0 +1,115 @@
+--- nginx-1.3.11/src/http/modules/ngx_http_log_module.c	2011-11-01 21:24:50.000000000 +0800
++++ nginx-1.3.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.3.11-no_Werror.patch

@@ -0,0 +1,24 @@
+diff -ur nginx-1.3.11/auto/cc/gcc nginx-1.3.11-patched/auto/cc/gcc
+--- nginx-1.3.11/auto/cc/gcc	2011-06-27 19:53:00.205737804 +0800
++++ nginx-1.3.11-patched/auto/cc/gcc	2011-06-27 19:53:13.837741087 +0800
+@@ -169,7 +169,7 @@
+ 
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"
+diff -ur nginx-1.3.11/auto/cc/icc nginx-1.3.11-patched/auto/cc/icc
+--- nginx-1.3.11/auto/cc/icc	2011-06-27 19:52:56.370157068 +0800
++++ nginx-1.3.11-patched/auto/cc/icc	2011-06-27 19:53:19.508916811 +0800
+@@ -139,7 +139,7 @@
+ esac
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"

patches/nginx-1.3.11-no_error_pages.patch

@@ -0,0 +1,90 @@
+--- nginx-1.3.11/src/http/ngx_http_core_module.c	2010-12-14 18:38:42.000000000 +0800
++++ nginx-1.3.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.3.11-no_pool.patch

@@ -0,0 +1,609 @@
+diff -ur nginx-1.3.11/src/core/nginx.h nginx-1.3.11-patched/src/core/nginx.h
+--- nginx-1.3.11/src/core/nginx.h	2011-08-29 17:30:22.000000000 +0800
++++ nginx-1.3.11-patched/src/core/nginx.h	2011-09-13 12:11:03.135622101 +0800
+@@ -10,7 +10,7 @@
+ 
+ 
+ #define nginx_version      1003011
+ #define NGINX_VERSION      "1.3.11"
+-#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown (no pool)"
+ 
+ #define NGINX_VAR          "NGINX"
+diff -urx '*~' -x '*.swp' nginx-1.3.11/src/core/ngx_array.c nginx-1.3.11-patched/src/core/ngx_array.c
+--- nginx-1.3.11/src/core/ngx_array.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.3.11-patched/src/core/ngx_array.c	2012-06-20 23:10:36.870722387 +0800
+@@ -28,6 +28,7 @@
+     a->size = size;
+     a->nalloc = n;
+     a->pool = p;
++    a->old_elts = NULL;
+ 
+     return a;
+ }
+@@ -36,26 +37,30 @@
+ 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) {
+ 
+@@ -65,29 +70,27 @@
+ 
+         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++;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            new = ngx_palloc(p, 2 * size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, size);
+-            a->elts = new;
+-            a->nalloc *= 2;
++        /* allocate a new array */
++
++        new = ngx_palloc(p, 2 * size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, size);
++
++        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;
+@@ -101,11 +104,10 @@
+ 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) {
+ 
+@@ -113,31 +115,27 @@
+ 
+         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
+-             */
+-
+-            p->d.last += size;
+-            a->nalloc += n;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
+-
+-            new = ngx_palloc(p, nalloc * a->size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, a->nelts * a->size);
+-            a->elts = new;
+-            a->nalloc = nalloc;
++        nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
++
++        new = ngx_palloc(p, nalloc * a->size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, a->nelts * a->size);
++
++        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 = nalloc;
+     }
+ 
+     elt = (u_char *) a->elts + a->size * a->nelts;
+diff -urx '*~' -x '*.swp' nginx-1.3.11/src/core/ngx_array.h nginx-1.3.11-patched/src/core/ngx_array.h
+--- nginx-1.3.11/src/core/ngx_array.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.3.11-patched/src/core/ngx_array.h	2012-06-20 23:25:38.800624960 +0800
+@@ -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;
++};
++
++
+ struct ngx_array_s {
+     void        *elts;
+     ngx_uint_t   nelts;
+     size_t       size;
+     ngx_uint_t   nalloc;
+     ngx_pool_t  *pool;
++
++    ngx_array_link_t *old_elts;
+ };
+ 
+ 
+@@ -40,6 +51,7 @@
+     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 -urx '*~' -x '*.swp' nginx-1.3.11/src/core/ngx_palloc.c nginx-1.3.11-patched/src/core/ngx_palloc.c
+--- nginx-1.3.11/src/core/ngx_palloc.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.3.11-patched/src/core/ngx_palloc.c	2012-06-20 22:56:30.148073066 +0800
+@@ -9,32 +9,23 @@
+ #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);
+-
+-
+ 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 +35,7 @@
+ 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 +46,9 @@
+         }
+     }
+ 
+-    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 +58,9 @@
+      * 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,172 +69,82 @@
+ 
+ #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;
+ 
+-void
+-ngx_reset_pool(ngx_pool_t *pool)
+-{
+-    ngx_pool_t        *p;
+-    ngx_pool_large_t  *l;
+-
+-    for (l = pool->large; l; l = l->next) {
+-        if (l->alloc) {
+-            ngx_free(l->alloc);
+-        }
+-    }
+-
+-    pool->large = NULL;
+-
+-    for (p = pool; p; p = p->d.next) {
+-        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
+-    }
++    ngx_free(pool);
+ }
+ 
+ 
+-void *
+-ngx_palloc(ngx_pool_t *pool, size_t size)
++void
++ngx_reset_pool(ngx_pool_t *pool)
+ {
+-    u_char      *m;
+-    ngx_pool_t  *p;
+-
+-    if (size <= pool->max) {
++    ngx_pool_data_t     *d, *n;
++    ngx_pool_data_t     *saved = NULL;
+ 
+-        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;
++    if (pool->d) {
++        for (d = pool->d, n = d->next; ; d = n, n = n->next) {
++            if (d->alloc == pool->log) {
++                saved = d;
++                continue;
+             }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
+-    }
+-
+-    return ngx_palloc_large(pool, size);
+-}
+-
++            ngx_free(d->alloc);
++            ngx_free(d);
+ 
+-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;
++            if (n == NULL) {
++                break;
+             }
++        }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
++        pool->d = saved;
+     }
+-
+-    return ngx_palloc_large(pool, size);
+ }
+ 
+ 
+-static void *
+-ngx_palloc_block(ngx_pool_t *pool, size_t size)
++void *
++ngx_malloc(ngx_pool_t *pool, size_t size)
+ {
+-    u_char      *m;
+-    size_t       psize;
+-    ngx_pool_t  *p, *new, *current;
++    ngx_pool_data_t     *d;
++    void                *p;
+ 
+-    psize = (size_t) (pool->d.end - (u_char *) pool);
+-
+-    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
+-    if (m == NULL) {
++    p = ngx_alloc(size, pool->log);
++    if (p == 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;
+-
+-    current = pool->current;
+-
+-    for (p = current; p->d.next; p = p->d.next) {
+-        if (p->d.failed++ > 4) {
+-            current = p->d.next;
+-        }
++    d = ngx_alloc(sizeof(ngx_pool_data_t), pool->log);
++    if (d == NULL){
++        ngx_free(p);
++        return NULL;
+     }
+ 
+-    p->d.next = new;
+-
+-    pool->current = current ? current : new;
+-
+-    return m;
++    d->alloc = p;
++    d->next = pool->d;
++    pool->d = d;
++    return p;
+ }
+ 
+ 
+-static void *
+-ngx_palloc_large(ngx_pool_t *pool, size_t size)
++void *
++ngx_palloc(ngx_pool_t *pool, size_t size)
+ {
+-    void              *p;
+-    ngx_uint_t         n;
+-    ngx_pool_large_t  *large;
+-
+-    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) {
+-        ngx_free(p);
+-        return NULL;
+-    }
++    return ngx_malloc(pool, size);
++}
+ 
+-    large->alloc = p;
+-    large->next = pool->large;
+-    pool->large = large;
+ 
+-    return p;
++void *
++ngx_pnalloc(ngx_pool_t *pool, size_t size)
++{
++    return ngx_malloc(pool, size);
+ }
+ 
+ 
+@@ -256,38 +152,48 @@
+ 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 -urx '*~' -x '*.swp' nginx-1.3.11/src/core/ngx_palloc.h nginx-1.3.11-patched/src/core/ngx_palloc.h
+--- nginx-1.3.11/src/core/ngx_palloc.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.3.11-patched/src/core/ngx_palloc.h	2012-06-21 10:35:47.463405863 +0800
+@@ -38,28 +38,21 @@
+ };
+ 
+ 
+-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.3.11-nonbuffered-upstream-truncation.patch

@@ -0,0 +1,63 @@
+--- nginx-1.3.11/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.3.11-patched/src/http/ngx_http_upstream.c	2012-09-09 21:58:04.727761891 -0700
+@@ -2383,7 +2383,7 @@
+ 
+     if (c->read->timedout) {
+         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
+-        ngx_http_upstream_finalize_request(r, u, 0);
++        ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
+         return;
+     }
+ 
+@@ -2430,13 +2430,17 @@
+             if (u->busy_bufs == NULL) {
+ 
+                 if (u->length == 0
+-                    || upstream->read->eof
+-                    || upstream->read->error)
++                    || (upstream->read->eof && u->headers_in.content_length_n == -1))
+                 {
+                     ngx_http_upstream_finalize_request(r, u, 0);
+                     return;
+                 }
+ 
++                if (upstream->read->eof || upstream->read->error) {
++                    ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++                    return;
++                }
++
+                 b->pos = b->start;
+                 b->last = b->start;
+             }
+@@ -2710,7 +2714,16 @@
+ #if 0
+             ngx_http_busy_unlock(u->conf->busy_lock, &u->busy_lock);
+ #endif
+-            ngx_http_upstream_finalize_request(r, u, 0);
++
++            if (p->upstream_done
++                || (p->upstream_eof && u->headers_in.content_length_n == -1))
++            {
++                ngx_http_upstream_finalize_request(r, u, 0);
++
++            } else {
++                ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++            }
++
+             return;
+         }
+     }
+@@ -3073,6 +3086,13 @@
+         && rc != NGX_HTTP_REQUEST_TIME_OUT
+         && (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
+     {
++        if (rc == NGX_ERROR) {
++            r->headers_out.status = NGX_HTTP_INTERNAL_SERVER_ERROR;
++
++        } else {
++            r->headers_out.status = rc;
++        }
++
+         rc = 0;
+     }
+ 

patches/nginx-1.3.11-resolver_wev_handler_segfault_with_poll.patch

@@ -0,0 +1,31 @@
+--- nginx-1.3.11/src/event/modules/ngx_poll_module.c	2012-01-18 07:07:43.000000000 -0800
++++ nginx-1.3.11-patched/src/event/modules/ngx_poll_module.c	2013-01-23 12:34:13.990781456 -0800
+@@ -367,11 +367,18 @@ ngx_poll_process_events(ngx_cycle_t *cyc
+              */
+ 
+             revents |= POLLIN|POLLOUT;
++            if (c->read->active) {
++                revents |= POLLIN;
++            }
++
++            if (c->write->active) {
++                revents |= POLLOUT;
++            }
+         }
+ 
+         found = 0;
+ 
+-        if (revents & POLLIN) {
++        if ((revents & POLLIN) && c->read->active) {
+             found = 1;
+ 
+             ev = c->read;
+@@ -388,7 +395,7 @@ ngx_poll_process_events(ngx_cycle_t *cyc
+             ngx_locked_post_event(ev, queue);
+         }
+ 
+-        if (revents & POLLOUT) {
++        if ((revents & POLLOUT) && c->write->active) {
+             found = 1;
+             ev = c->write;
+ 

patches/nginx-1.3.11-server_header.patch

@@ -0,0 +1,26 @@
+diff -ur lz-nginx-1.3.11/nginx-1.3.11/src/core/nginx.h lz-nginx-1.3.11-patched/nginx-1.3.11/src/core/nginx.h
+--- lz-nginx-1.3.11/nginx-1.3.11/src/core/nginx.h	2010-02-12 17:31:01.000000000 +0800
++++ lz-nginx-1.3.11-patched/nginx-1.3.11/src/core/nginx.h	2010-03-30 10:52:13.240702627 +0800
+@@ -10,7 +10,7 @@
+ 
+ #define nginx_version         1003011
+ #define NGINX_VERSION      "1.3.11"
+-#define NGINX_VER          "nginx/" NGINX_VERSION
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
+ 
+ #define NGINX_VAR          "NGINX"
+ #define NGX_OLDPID_EXT     ".oldbin"
+Only in lz-nginx-1.3.11-patched/nginx-1.3.11/src/core: nginx.h.orig
+Only in lz-nginx-1.3.11-patched/nginx-1.3.11/src/core: nginx.h.rej
+diff -ur lz-nginx-1.3.11/nginx-1.3.11/src/http/ngx_http_header_filter_module.c lz-nginx-1.3.11-patched/nginx-1.3.11/src/http/ngx_http_header_filter_module.c
+--- lz-nginx-1.3.11/nginx-1.3.11/src/http/ngx_http_header_filter_module.c	2010-03-03 23:14:04.000000000 +0800
++++ lz-nginx-1.3.11-patched/nginx-1.3.11/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: ngx_openresty" CRLF;
+ static char ngx_http_server_full_string[] = "Server: " NGINX_VER CRLF;
+ 
+ 

patches/nginx-1.3.11-slab_alloc_no_memory_as_info.patch

@@ -0,0 +1,11 @@
+--- nginx-1.3.11/src/core/ngx_slab.c	2012-09-24 11:34:04.000000000 -0700
++++ nginx-1.3.11-patched/src/core/ngx_slab.c	2012-12-05 20:47:07.296694952 -0800
+@@ -657,7 +657,7 @@ ngx_slab_alloc_pages(ngx_slab_pool_t *po
+         }
+     }
+ 
+-    ngx_slab_error(pool, NGX_LOG_CRIT, "ngx_slab_alloc() failed: no memory");
++    ngx_slab_error(pool, NGX_LOG_INFO, "ngx_slab_alloc() failed: no memory");
+ 
+     return NULL;
+ }

patches/nginx-1.3.11-upstream_pipelining.patch

@@ -0,0 +1,40 @@
+diff -rudp nginx-1.3.11/src/http/ngx_http_upstream.c nginx-1.3.11-patched/src/http/ngx_http_upstream.c
+--- nginx-1.3.11/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.3.11-patched/src/http/ngx_http_upstream.c	2012-12-05 14:46:41.741173058 -0800
+@@ -1216,6 +1216,7 @@ ngx_http_upstream_connect(ngx_http_reque
+     }
+ 
+     u->request_sent = 0;
++    u->request_all_sent = 0;
+ 
+     if (rc == NGX_AGAIN) {
+         ngx_add_timer(c->write, u->conf->connect_timeout);
+@@ -1418,6 +1419,8 @@ ngx_http_upstream_send_request(ngx_http_
+ 
+     /* rc == NGX_OK */
+ 
++    u->request_all_sent = 1;
++
+     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
+         if (ngx_tcp_push(c->fd) == NGX_ERROR) {
+             ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
+@@ -1484,7 +1487,7 @@ ngx_http_upstream_send_request_handler(n
+ 
+ #endif
+ 
+-    if (u->header_sent) {
++    if (u->request_all_sent) {
+         u->write_event_handler = ngx_http_upstream_dummy_handler;
+ 
+         (void) ngx_handle_write_event(c->write, 0);
+diff -rudp nginx-1.3.11/src/http/ngx_http_upstream.h nginx-1.3.11-patched/src/http/ngx_http_upstream.h
+--- nginx-1.3.11/src/http/ngx_http_upstream.h	2012-02-13 03:01:58.000000000 -0800
++++ nginx-1.3.11-patched/src/http/ngx_http_upstream.h	2012-12-05 14:41:09.763514741 -0800
+@@ -324,6 +324,7 @@ struct ngx_http_upstream_s {
+     unsigned                         keepalive:1;
+ 
+     unsigned                         request_sent:1;
++    unsigned                         request_all_sent:1;
+     unsigned                         header_sent:1;
+ };
+ 

patches/nginx-1.3.11-upstream_test_connect_kqueue.patch

@@ -0,0 +1,26 @@
+--- nginx-1.3.11/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.3.11-patched/src/http/ngx_http_upstream.c	2012-11-05 21:17:38.000000000 -0800
+@@ -1808,10 +1808,22 @@ ngx_http_upstream_test_connect(ngx_conne
+ 
+ #if (NGX_HAVE_KQUEUE)
+ 
++    ngx_event_t *ev;
++
+     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT)  {
+         if (c->write->pending_eof) {
++            ev = c->write;
++
++        } else if (c->read->pending_eof) {
++            ev = c->read;
++
++        } else {
++            ev = NULL;
++        }
++
++        if (ev) {
+             c->log->action = "connecting to upstream";
+-            (void) ngx_connection_error(c, c->write->kq_errno,
++            (void) ngx_connection_error(c, ev->kq_errno,
+                                     "kevent() reported that connect() failed");
+             return NGX_ERROR;
+         }

patches/nginx-1.3.4-dtrace.patch

@@ -307,22 +307,25 @@ index c506d3d..cbbfbf1 100644
 +
 +DTRACE_FROM_SYSTEMTAP=YES
 diff --git a/auto/sources b/auto/sources
-index 374ad66..3c76cac 100644
+index 374ad66..82dbc88 100644
 --- a/auto/sources
 +++ b/auto/sources
-@@ -39,6 +39,11 @@ CORE_DEPS="src/core/nginx.h \
-            src/core/ngx_crypt.h"
- 
- 
+@@ -36,7 +36,13 @@ CORE_DEPS="src/core/nginx.h \
+            src/core/ngx_conf_file.h \
+            src/core/ngx_resolver.h \
+            src/core/ngx_open_file_cache.h \
+-           src/core/ngx_crypt.h"
++           src/core/ngx_crypt.h \
++           src/core/ngx_core_probe.h"
++
++
 +if [ $NGX_DTRACE = YES ]; then
 +    CORE_DEPS="$CORE_DEPS objs/ngx_dtrace_provider.h"
 +fi
-+
-+
+ 
+ 
  CORE_SRCS="src/core/nginx.c \
-            src/core/ngx_log.c \
-            src/core/ngx_palloc.c \
-@@ -82,14 +87,15 @@ OPENSSL_SRCS=src/event/ngx_event_openssl.c
+@@ -82,14 +88,15 @@ OPENSSL_SRCS=src/event/ngx_event_openssl.c
  
  EVENT_MODULES="ngx_events_module ngx_event_core_module"
  
@@ -340,7 +343,7 @@ index 374ad66..3c76cac 100644
  
  EVENT_SRCS="src/event/ngx_event.c \
              src/event/ngx_event_timer.c \
-@@ -291,7 +297,8 @@ HTTP_DEPS="src/http/ngx_http.h \
+@@ -291,7 +298,8 @@ HTTP_DEPS="src/http/ngx_http.h \
             src/http/ngx_http_script.h \
             src/http/ngx_http_upstream.h \
             src/http/ngx_http_upstream_round_robin.h \
@@ -350,7 +353,7 @@ index 374ad66..3c76cac 100644
  
  HTTP_SRCS="src/http/ngx_http.c \
             src/http/ngx_http_core_module.c \
-@@ -524,3 +531,8 @@ NGX_GOOGLE_PERFTOOLS_MODULE=ngx_google_perftools_module
+@@ -524,3 +532,8 @@ NGX_GOOGLE_PERFTOOLS_MODULE=ngx_google_perftools_module
  NGX_GOOGLE_PERFTOOLS_SRCS=src/misc/ngx_google_perftools_module.c
  
  NGX_CPP_TEST_SRCS=src/misc/ngx_cpp_test_module.cpp
@@ -397,14 +400,99 @@ index 45ea154..332c011 100755
  
  if test -z "$NGX_PLATFORM"; then
      echo "checking for OS"
+diff --git a/src/core/ngx_core_probe.h b/src/core/ngx_core_probe.h
+new file mode 100644
+index 0000000..91bf91e
+--- /dev/null
++++ b/src/core/ngx_core_probe.h
+@@ -0,0 +1,25 @@
++#ifndef _NGX_CORE_PROBE_H_INCLUDED_
++#define _NGX_CORE_PROBE_H_INCLUDED_
++
++
++#include <ngx_config.h>
++#include <ngx_core.h>
++#include <ngx_event.h>
++
++
++#if (NGX_DTRACE)
++
++#include <ngx_http.h>
++#include <ngx_dtrace_provider.h>
++
++#define ngx_core_probe_create_pool_done(pool, size)                             \
++    NGINX_CREATE_POOL_DONE(pool, size)
++
++#else /* !(NGX_DTRACE) */
++
++#define ngx_core_probe_create_pool_done(pool, size)
++
++#endif
++
++
++#endif /* _NGX_CORE_PROBE_H_INCLUDED_ */
+diff --git a/src/core/ngx_palloc.c b/src/core/ngx_palloc.c
+index efbc244..8d81aab 100644
+--- a/src/core/ngx_palloc.c
++++ b/src/core/ngx_palloc.c
+@@ -7,6 +7,7 @@
+ 
+ #include <ngx_config.h>
+ #include <ngx_core.h>
++#include <ngx_core_probe.h>
+ 
+ 
+ static void *ngx_palloc_block(ngx_pool_t *pool, size_t size);
+@@ -37,6 +38,8 @@ ngx_create_pool(size_t size, ngx_log_t *log)
+     p->cleanup = NULL;
+     p->log = log;
+ 
++    ngx_core_probe_create_pool_done(p, size);
++
+     return p;
+ }
+ 
 diff --git a/src/dtrace/nginx.stp b/src/dtrace/nginx.stp
 new file mode 100644
-index 0000000..3dde1be
+index 0000000..5bae185
 --- /dev/null
 +++ b/src/dtrace/nginx.stp
-@@ -0,0 +1,199 @@
+@@ -0,0 +1,269 @@
 +/* tapset for nginx */
 +
++
++function ngx_indent(n, delta)
++{
++    s = ""
++    for (i = 0; i < n; i++) {
++        s .= delta
++    }
++
++    return s
++}
++
++
++function ngx_http_subreq_depth(r)
++{
++    depth = 0
++
++    for (pr = @cast(r, "ngx_http_request_t", "NGX_SBIN_PATH")->parent;
++         pr != 0;
++         pr = @cast(pr, "ngx_http_request_t", "NGX_SBIN_PATH")->parent)
++    {
++        depth++
++    }
++
++    return depth
++}
++
++
++function ngx_http_req_parent(r)
++{
++    return @cast(r, "ngx_http_request_s", "NGX_SBIN_PATH")->parent
++}
++
++
 +/* retrieve the request uri string from the ngx_http_request_t pointer */
 +function ngx_http_req_uri(r)
 +{
@@ -500,6 +588,24 @@ index 0000000..3dde1be
 +}
 +
 +
++function ngx_buf_last_buf(b)
++{
++    return @cast(b, "ngx_buf_t", "/home/agentzh/git/lua-nginx-module/work/nginx/sbin/nginx")->last_buf
++}
++
++
++function ngx_buf_sync(b)
++{
++    return @cast(b, "ngx_buf_t", "/home/agentzh/git/lua-nginx-module/work/nginx/sbin/nginx")->sync
++}
++
++
++function ngx_buf_flush(b)
++{
++    return @cast(b, "ngx_buf_t", "/home/agentzh/git/lua-nginx-module/work/nginx/sbin/nginx")->flush
++}
++
++
 +function ngx_buf_size(b)
 +{
 +    if (ngx_buf_in_memory(b)) {
@@ -532,7 +638,26 @@ index 0000000..3dde1be
 +    cl = input
 +    while (cl) {
 +        buf = ngx_chain_buf(cl)
-+        out .= sprintf("[%s]", text_str(ngx_buf_data(buf)))
++
++        if (ngx_buf_in_memory(buf)) {
++            out .= sprintf("[%s]", text_str(ngx_buf_data(buf)))
++
++        } else {
++            out .= "\"\""
++        }
++
++        if (ngx_buf_last_buf(buf)) {
++            out .= "<eof>"
++        }
++
++        if (ngx_buf_sync(buf)) {
++            out .= "<sync>"
++        }
++
++        if (ngx_buf_flush(buf)) {
++            out .= "<flush>"
++        }
++
 +        cl = ngx_chain_next(cl)
 +        if (cl) {
 +            out .= sprintf(" ")
@@ -604,10 +729,10 @@ index 0000000..3dde1be
 +
 diff --git a/src/dtrace/nginx_provider.d b/src/dtrace/nginx_provider.d
 new file mode 100644
-index 0000000..e583a52
+index 0000000..147ca12
 --- /dev/null
 +++ b/src/dtrace/nginx_provider.d
-@@ -0,0 +1,39 @@
+@@ -0,0 +1,41 @@
 +typedef struct { int dummy; } ngx_http_request_t;
 +typedef struct { int dummy; } ngx_str_t;
 +typedef int64_t ngx_int_t;
@@ -617,6 +742,7 @@ index 0000000..e583a52
 +typedef struct { int dummy; } ngx_http_module_t;
 +typedef struct { int dummy; } ngx_table_elt_t;
 +typedef struct { int dummy; } ngx_event_t;
++typedef struct { int dummy; } ngx_pool_t;
 +typedef char unsigned u_char;
 +
 +
@@ -638,6 +764,7 @@ index 0000000..e583a52
 +    probe timer__add(ngx_event_t *ev, ngx_msec_t timer);
 +    probe timer__del(ngx_event_t *ev);
 +    probe timer__expire(ngx_event_t *ev);
++    probe create__pool__done(ngx_pool_t *pool, size_t size);
 +};
 +
 +

patches/nginx-1.3.6-allow_request_body_updating.patch

@@ -0,0 +1,128 @@
+diff '--exclude=*~' -ur nginx-1.3.6/src/http/ngx_http_core_module.c nginx-1.3.6-patched/src/http/ngx_http_core_module.c
+--- nginx-1.3.6/src/http/ngx_http_core_module.c	2012-06-04 04:58:12.000000000 -0700
++++ nginx-1.3.6-patched/src/http/ngx_http_core_module.c	2012-07-21 12:09:17.468576485 -0700
+@@ -2420,6 +2420,8 @@
+ 
+     sr->request_body = r->request_body;
+ 
++    sr->content_length_n = -1;
++
+     sr->method = NGX_HTTP_GET;
+     sr->http_version = r->http_version;
+ 
+diff '--exclude=*~' -ur nginx-1.3.6/src/http/ngx_http_request_body.c nginx-1.3.6-patched/src/http/ngx_http_request_body.c
+--- nginx-1.3.6/src/http/ngx_http_request_body.c	2012-04-12 12:35:41.000000000 -0700
++++ nginx-1.3.6-patched/src/http/ngx_http_request_body.c	2012-07-21 12:08:30.655376967 -0700
+@@ -39,7 +39,7 @@
+ 
+     r->main->count++;
+ 
+-    if (r->request_body || r->discard_body) {
++    if (r->request_body || r->discard_body || r->content_length_n == 0) {
+         post_handler(r);
+         return NGX_OK;
+     }
+@@ -441,7 +441,7 @@
+     ssize_t       size;
+     ngx_event_t  *rev;
+ 
+-    if (r != r->main || r->discard_body) {
++    if (r != r->main || r->discard_body || r->content_length_n == 0) {
+         return NGX_OK;
+     }
+ 
+@@ -457,20 +457,22 @@
+         ngx_del_timer(rev);
+     }
+ 
+-    if (r->headers_in.content_length_n <= 0 || r->request_body) {
++    r->content_length_n = r->headers_in.content_length_n;
++
++    if (r->content_length_n <= 0 || r->request_body) {
+         return NGX_OK;
+     }
+ 
+     size = r->header_in->last - r->header_in->pos;
+ 
+     if (size) {
+-        if (r->headers_in.content_length_n > size) {
++        if (r->content_length_n > size) {
+             r->header_in->pos += size;
+-            r->headers_in.content_length_n -= size;
++            r->content_length_n -= size;
+ 
+         } else {
+-            r->header_in->pos += (size_t) r->headers_in.content_length_n;
+-            r->headers_in.content_length_n = 0;
++            r->header_in->pos += (size_t) r->content_length_n;
++            r->content_length_n = 0;
+             return NGX_OK;
+         }
+     }
+@@ -569,7 +571,7 @@
+                    "http read discarded body");
+ 
+     for ( ;; ) {
+-        if (r->headers_in.content_length_n == 0) {
++        if (r->content_length_n == 0) {
+             r->read_event_handler = ngx_http_block_reading;
+             return NGX_OK;
+         }
+@@ -578,9 +580,9 @@
+             return NGX_AGAIN;
+         }
+ 
+-        size = (r->headers_in.content_length_n > NGX_HTTP_DISCARD_BUFFER_SIZE) ?
++        size = (r->content_length_n > NGX_HTTP_DISCARD_BUFFER_SIZE) ?
+                    NGX_HTTP_DISCARD_BUFFER_SIZE:
+-                   (size_t) r->headers_in.content_length_n;
++                   (size_t) r->content_length_n;
+ 
+         n = r->connection->recv(r->connection, buffer, size);
+ 
+@@ -597,7 +599,7 @@
+             return NGX_OK;
+         }
+ 
+-        r->headers_in.content_length_n -= n;
++        r->content_length_n -= n;
+     }
+ }
+ 
+Only in nginx-1.3.6-patched/src/http: ngx_http_request_body.c.orig
+diff '--exclude=*~' -ur nginx-1.3.6/src/http/ngx_http_request.c nginx-1.3.6-patched/src/http/ngx_http_request.c
+--- nginx-1.3.6/src/http/ngx_http_request.c	2012-06-05 06:52:37.000000000 -0700
++++ nginx-1.3.6-patched/src/http/ngx_http_request.c	2012-07-21 12:08:30.656376973 -0700
+@@ -287,6 +287,8 @@
+ 
+         r->pipeline = hc->pipeline;
+ 
++        r->content_length_n = -1;
++
+         if (hc->nbusy) {
+             r->header_in = hc->busy[0];
+         }
+@@ -298,6 +300,8 @@
+             return;
+         }
+ 
++        r->content_length_n = -1;
++
+         hc->request = r;
+     }
+ 
+Only in nginx-1.3.6-patched/src/http: ngx_http_request.c.orig
+diff '--exclude=*~' -ur nginx-1.3.6/src/http/ngx_http_request.h nginx-1.3.6-patched/src/http/ngx_http_request.h
+--- nginx-1.3.6/src/http/ngx_http_request.h	2012-02-28 06:54:23.000000000 -0800
++++ nginx-1.3.6-patched/src/http/ngx_http_request.h	2012-07-21 12:08:30.657376978 -0700
+@@ -368,6 +368,9 @@
+     ngx_pool_t                       *pool;
+     ngx_buf_t                        *header_in;
+ 
++    off_t                             content_length_n;
++                                          /* for discarding request body */
++
+     ngx_http_headers_in_t             headers_in;
+     ngx_http_headers_out_t            headers_out;
+ 
+Only in nginx-1.3.6-patched/src/http: ngx_http_request.h.orig

patches/nginx-1.3.6-channel-uninit-params.patch

@@ -0,0 +1,42 @@
+diff -urp nginx-1.3.6/src/os/unix/ngx_channel.c nginx-1.3.6-patched/src/os/unix/ngx_channel.c
+--- nginx-1.3.6/src/os/unix/ngx_channel.c	2012-01-18 07:07:43.000000000 -0800
++++ nginx-1.3.6-patched/src/os/unix/ngx_channel.c	2012-09-17 11:33:09.215394217 -0700
+@@ -31,6 +31,8 @@ ngx_write_channel(ngx_socket_t s, ngx_ch
+         msg.msg_controllen = 0;
+ 
+     } else {
++        ngx_memzero(&cmsg, sizeof(cmsg));
++
+         msg.msg_control = (caddr_t) &cmsg;
+         msg.msg_controllen = sizeof(cmsg);
+ 
+diff -urp nginx-1.3.6/src/os/unix/ngx_process_cycle.c nginx-1.3.6-patched/src/os/unix/ngx_process_cycle.c
+--- nginx-1.3.6/src/os/unix/ngx_process_cycle.c	2012-07-02 09:23:14.000000000 -0700
++++ nginx-1.3.6-patched/src/os/unix/ngx_process_cycle.c	2012-09-17 11:33:09.214394215 -0700
+@@ -356,6 +356,8 @@ ngx_start_worker_processes(ngx_cycle_t *
+ 
+     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_OPEN_CHANNEL;
+ 
+     for (i = 0; i < n; i++) {
+@@ -463,6 +465,8 @@ ngx_signal_worker_processes(ngx_cycle_t
+     ngx_err_t      err;
+     ngx_channel_t  ch;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+ #if (NGX_BROKEN_SCM_RIGHTS)
+ 
+     ch.command = 0;
+@@ -564,6 +568,8 @@ ngx_reap_children(ngx_cycle_t *cycle)
+     ngx_channel_t     ch;
+     ngx_core_conf_t  *ccf;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_CLOSE_CHANNEL;
+     ch.fd = -1;
+ 

patches/nginx-1.3.6-location_if_inherits_proxy.patch

@@ -0,0 +1,15 @@
+--- nginx-1.3.6/src/http/modules/ngx_http_proxy_module.c	2012-04-23 18:40:01.000000000 +0800
++++ nginx-1.3.6-patched/src/http/modules/ngx_http_proxy_module.c	2012-06-24 12:48:57.289834450 +0800
+@@ -3023,8 +3023,10 @@
+ 
+     if (conf->upstream.upstream || conf->proxy_lengths) {
+         clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
+-        if (clcf->handler == NULL && clcf->lmt_excpt) {
+-            clcf->handler = ngx_http_proxy_handler;
++        if (clcf->handler == NULL) {
++            if (clcf->lmt_excpt) {
++                clcf->handler = ngx_http_proxy_handler;
++            }
+             conf->location = prev->location;
+         }
+     }

patches/nginx-1.3.6-log_escape_non_ascii.patch

@@ -0,0 +1,115 @@
+--- nginx-1.3.6/src/http/modules/ngx_http_log_module.c	2011-11-01 21:24:50.000000000 +0800
++++ nginx-1.3.6-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.3.6-no_Werror.patch

@@ -0,0 +1,24 @@
+diff -ur nginx-1.3.6/auto/cc/gcc nginx-1.3.6-patched/auto/cc/gcc
+--- nginx-1.3.6/auto/cc/gcc	2011-06-27 19:53:00.205737804 +0800
++++ nginx-1.3.6-patched/auto/cc/gcc	2011-06-27 19:53:13.837741087 +0800
+@@ -169,7 +169,7 @@
+ 
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"
+diff -ur nginx-1.3.6/auto/cc/icc nginx-1.3.6-patched/auto/cc/icc
+--- nginx-1.3.6/auto/cc/icc	2011-06-27 19:52:56.370157068 +0800
++++ nginx-1.3.6-patched/auto/cc/icc	2011-06-27 19:53:19.508916811 +0800
+@@ -139,7 +139,7 @@
+ esac
+ 
+ # stop on warning
+-CFLAGS="$CFLAGS -Werror"
++#CFLAGS="$CFLAGS -Werror"
+ 
+ # debug
+ CFLAGS="$CFLAGS -g"

patches/nginx-1.3.6-no_error_pages.patch

@@ -0,0 +1,90 @@
+--- nginx-1.3.6/src/http/ngx_http_core_module.c	2010-12-14 18:38:42.000000000 +0800
++++ nginx-1.3.6-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.3.6-no_pool.patch

@@ -0,0 +1,609 @@
+diff -ur nginx-1.3.6/src/core/nginx.h nginx-1.3.6-patched/src/core/nginx.h
+--- nginx-1.3.6/src/core/nginx.h	2011-08-29 17:30:22.000000000 +0800
++++ nginx-1.3.6-patched/src/core/nginx.h	2011-09-13 12:11:03.135622101 +0800
+@@ -10,7 +10,7 @@
+ 
+ 
+ #define nginx_version      1003006
+ #define NGINX_VERSION      "1.3.6"
+-#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown (no pool)"
+ 
+ #define NGINX_VAR          "NGINX"
+diff -urx '*~' -x '*.swp' nginx-1.3.6/src/core/ngx_array.c nginx-1.3.6-patched/src/core/ngx_array.c
+--- nginx-1.3.6/src/core/ngx_array.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.3.6-patched/src/core/ngx_array.c	2012-06-20 23:10:36.870722387 +0800
+@@ -28,6 +28,7 @@
+     a->size = size;
+     a->nalloc = n;
+     a->pool = p;
++    a->old_elts = NULL;
+ 
+     return a;
+ }
+@@ -36,26 +37,30 @@
+ 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) {
+ 
+@@ -65,29 +70,27 @@
+ 
+         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++;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            new = ngx_palloc(p, 2 * size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, size);
+-            a->elts = new;
+-            a->nalloc *= 2;
++        /* allocate a new array */
++
++        new = ngx_palloc(p, 2 * size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, size);
++
++        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;
+@@ -101,11 +104,10 @@
+ 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) {
+ 
+@@ -113,31 +115,27 @@
+ 
+         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
+-             */
+-
+-            p->d.last += size;
+-            a->nalloc += n;
+-
+-        } else {
+-            /* allocate a new array */
+-
+-            nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
+-
+-            new = ngx_palloc(p, nalloc * a->size);
+-            if (new == NULL) {
+-                return NULL;
+-            }
+-
+-            ngx_memcpy(new, a->elts, a->nelts * a->size);
+-            a->elts = new;
+-            a->nalloc = nalloc;
++        nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);
++
++        new = ngx_palloc(p, nalloc * a->size);
++        if (new == NULL) {
++            return NULL;
++        }
++
++        ngx_memcpy(new, a->elts, a->nelts * a->size);
++
++        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 = nalloc;
+     }
+ 
+     elt = (u_char *) a->elts + a->size * a->nelts;
+diff -urx '*~' -x '*.swp' nginx-1.3.6/src/core/ngx_array.h nginx-1.3.6-patched/src/core/ngx_array.h
+--- nginx-1.3.6/src/core/ngx_array.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.3.6-patched/src/core/ngx_array.h	2012-06-20 23:25:38.800624960 +0800
+@@ -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;
++};
++
++
+ struct ngx_array_s {
+     void        *elts;
+     ngx_uint_t   nelts;
+     size_t       size;
+     ngx_uint_t   nalloc;
+     ngx_pool_t  *pool;
++
++    ngx_array_link_t *old_elts;
+ };
+ 
+ 
+@@ -40,6 +51,7 @@
+     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 -urx '*~' -x '*.swp' nginx-1.3.6/src/core/ngx_palloc.c nginx-1.3.6-patched/src/core/ngx_palloc.c
+--- nginx-1.3.6/src/core/ngx_palloc.c	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.3.6-patched/src/core/ngx_palloc.c	2012-06-20 22:56:30.148073066 +0800
+@@ -9,32 +9,23 @@
+ #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);
+-
+-
+ 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 +35,7 @@
+ 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 +46,9 @@
+         }
+     }
+ 
+-    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 +58,9 @@
+      * 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,172 +69,82 @@
+ 
+ #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;
+ 
+-void
+-ngx_reset_pool(ngx_pool_t *pool)
+-{
+-    ngx_pool_t        *p;
+-    ngx_pool_large_t  *l;
+-
+-    for (l = pool->large; l; l = l->next) {
+-        if (l->alloc) {
+-            ngx_free(l->alloc);
+-        }
+-    }
+-
+-    pool->large = NULL;
+-
+-    for (p = pool; p; p = p->d.next) {
+-        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
+-    }
++    ngx_free(pool);
+ }
+ 
+ 
+-void *
+-ngx_palloc(ngx_pool_t *pool, size_t size)
++void
++ngx_reset_pool(ngx_pool_t *pool)
+ {
+-    u_char      *m;
+-    ngx_pool_t  *p;
+-
+-    if (size <= pool->max) {
++    ngx_pool_data_t     *d, *n;
++    ngx_pool_data_t     *saved = NULL;
+ 
+-        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;
++    if (pool->d) {
++        for (d = pool->d, n = d->next; ; d = n, n = n->next) {
++            if (d->alloc == pool->log) {
++                saved = d;
++                continue;
+             }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
+-    }
+-
+-    return ngx_palloc_large(pool, size);
+-}
+-
++            ngx_free(d->alloc);
++            ngx_free(d);
+ 
+-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;
++            if (n == NULL) {
++                break;
+             }
++        }
+ 
+-            p = p->d.next;
+-
+-        } while (p);
+-
+-        return ngx_palloc_block(pool, size);
++        pool->d = saved;
+     }
+-
+-    return ngx_palloc_large(pool, size);
+ }
+ 
+ 
+-static void *
+-ngx_palloc_block(ngx_pool_t *pool, size_t size)
++void *
++ngx_malloc(ngx_pool_t *pool, size_t size)
+ {
+-    u_char      *m;
+-    size_t       psize;
+-    ngx_pool_t  *p, *new, *current;
++    ngx_pool_data_t     *d;
++    void                *p;
+ 
+-    psize = (size_t) (pool->d.end - (u_char *) pool);
+-
+-    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
+-    if (m == NULL) {
++    p = ngx_alloc(size, pool->log);
++    if (p == 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;
+-
+-    current = pool->current;
+-
+-    for (p = current; p->d.next; p = p->d.next) {
+-        if (p->d.failed++ > 4) {
+-            current = p->d.next;
+-        }
++    d = ngx_alloc(sizeof(ngx_pool_data_t), pool->log);
++    if (d == NULL){
++        ngx_free(p);
++        return NULL;
+     }
+ 
+-    p->d.next = new;
+-
+-    pool->current = current ? current : new;
+-
+-    return m;
++    d->alloc = p;
++    d->next = pool->d;
++    pool->d = d;
++    return p;
+ }
+ 
+ 
+-static void *
+-ngx_palloc_large(ngx_pool_t *pool, size_t size)
++void *
++ngx_palloc(ngx_pool_t *pool, size_t size)
+ {
+-    void              *p;
+-    ngx_uint_t         n;
+-    ngx_pool_large_t  *large;
+-
+-    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) {
+-        ngx_free(p);
+-        return NULL;
+-    }
++    return ngx_malloc(pool, size);
++}
+ 
+-    large->alloc = p;
+-    large->next = pool->large;
+-    pool->large = large;
+ 
+-    return p;
++void *
++ngx_pnalloc(ngx_pool_t *pool, size_t size)
++{
++    return ngx_malloc(pool, size);
+ }
+ 
+ 
+@@ -256,38 +152,48 @@
+ 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 -urx '*~' -x '*.swp' nginx-1.3.6/src/core/ngx_palloc.h nginx-1.3.6-patched/src/core/ngx_palloc.h
+--- nginx-1.3.6/src/core/ngx_palloc.h	2012-02-06 04:02:59.000000000 +0800
++++ nginx-1.3.6-patched/src/core/ngx_palloc.h	2012-06-21 10:35:47.463405863 +0800
+@@ -38,28 +38,21 @@
+ };
+ 
+ 
+-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.3.6-nonbuffered-upstream-truncation.patch

@@ -0,0 +1,63 @@
+--- nginx-1.3.6/src/http/ngx_http_upstream.c	2012-08-06 10:34:08.000000000 -0700
++++ nginx-1.3.6-patched/src/http/ngx_http_upstream.c	2012-09-09 21:58:04.727761891 -0700
+@@ -2383,7 +2383,7 @@
+ 
+     if (c->read->timedout) {
+         ngx_connection_error(c, NGX_ETIMEDOUT, "upstream timed out");
+-        ngx_http_upstream_finalize_request(r, u, 0);
++        ngx_http_upstream_finalize_request(r, u, NGX_HTTP_GATEWAY_TIME_OUT);
+         return;
+     }
+ 
+@@ -2430,13 +2430,17 @@
+             if (u->busy_bufs == NULL) {
+ 
+                 if (u->length == 0
+-                    || upstream->read->eof
+-                    || upstream->read->error)
++                    || (upstream->read->eof && u->headers_in.content_length_n == -1))
+                 {
+                     ngx_http_upstream_finalize_request(r, u, 0);
+                     return;
+                 }
+ 
++                if (upstream->read->eof || upstream->read->error) {
++                    ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++                    return;
++                }
++
+                 b->pos = b->start;
+                 b->last = b->start;
+             }
+@@ -2710,7 +2714,16 @@
+ #if 0
+             ngx_http_busy_unlock(u->conf->busy_lock, &u->busy_lock);
+ #endif
+-            ngx_http_upstream_finalize_request(r, u, 0);
++
++            if (p->upstream_done
++                || (p->upstream_eof && u->headers_in.content_length_n == -1))
++            {
++                ngx_http_upstream_finalize_request(r, u, 0);
++
++            } else {
++                ngx_http_upstream_finalize_request(r, u, NGX_HTTP_BAD_GATEWAY);
++            }
++
+             return;
+         }
+     }
+@@ -3073,6 +3086,13 @@
+         && rc != NGX_HTTP_REQUEST_TIME_OUT
+         && (rc == NGX_ERROR || rc >= NGX_HTTP_SPECIAL_RESPONSE))
+     {
++        if (rc == NGX_ERROR) {
++            r->headers_out.status = NGX_HTTP_INTERNAL_SERVER_ERROR;
++
++        } else {
++            r->headers_out.status = rc;
++        }
++
+         rc = 0;
+     }
+ 

patches/nginx-1.3.6-server_header.patch

@@ -0,0 +1,26 @@
+diff -ur lz-nginx-1.3.6/nginx-1.3.6/src/core/nginx.h lz-nginx-1.3.6-patched/nginx-1.3.6/src/core/nginx.h
+--- lz-nginx-1.3.6/nginx-1.3.6/src/core/nginx.h	2010-02-12 17:31:01.000000000 +0800
++++ lz-nginx-1.3.6-patched/nginx-1.3.6/src/core/nginx.h	2010-03-30 10:52:13.240702627 +0800
+@@ -10,7 +10,7 @@
+ 
+ #define nginx_version         1003006
+ #define NGINX_VERSION      "1.3.6"
+-#define NGINX_VER          "nginx/" NGINX_VERSION
++#define NGINX_VER          "ngx_openresty/" NGINX_VERSION ".unknown"
+ 
+ #define NGINX_VAR          "NGINX"
+ #define NGX_OLDPID_EXT     ".oldbin"
+Only in lz-nginx-1.3.6-patched/nginx-1.3.6/src/core: nginx.h.orig
+Only in lz-nginx-1.3.6-patched/nginx-1.3.6/src/core: nginx.h.rej
+diff -ur lz-nginx-1.3.6/nginx-1.3.6/src/http/ngx_http_header_filter_module.c lz-nginx-1.3.6-patched/nginx-1.3.6/src/http/ngx_http_header_filter_module.c
+--- lz-nginx-1.3.6/nginx-1.3.6/src/http/ngx_http_header_filter_module.c	2010-03-03 23:14:04.000000000 +0800
++++ lz-nginx-1.3.6-patched/nginx-1.3.6/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: ngx_openresty" CRLF;
+ static char ngx_http_server_full_string[] = "Server: " NGINX_VER CRLF;
+ 
+ 

patches/nginx-1.3.6-upstream_pipelining.patch

@@ -0,0 +1,32 @@
+diff -ur nginx-1.3.6/src/http/ngx_http_upstream.c nginx-1.3.6-patched/src/http/ngx_http_upstream.c
+--- nginx-1.3.6/src/http/ngx_http_upstream.c	2011-12-14 02:34:34.000000000 +0800
++++ nginx-1.3.6-patched/src/http/ngx_http_upstream.c	2012-03-21 21:20:17.333111806 +0800
+@@ -1385,6 +1385,8 @@
+ 
+     /* rc == NGX_OK */
+ 
++    u->request_all_sent = 1;
++
+     if (c->tcp_nopush == NGX_TCP_NOPUSH_SET) {
+         if (ngx_tcp_push(c->fd) == NGX_ERROR) {
+             ngx_log_error(NGX_LOG_CRIT, c->log, ngx_socket_errno,
+@@ -1451,7 +1453,7 @@
+ 
+ #endif
+ 
+-    if (u->header_sent) {
++    if (u->request_all_sent) {
+         u->write_event_handler = ngx_http_upstream_dummy_handler;
+ 
+         (void) ngx_handle_write_event(c->write, 0);
+diff -ur nginx-1.3.6/src/http/ngx_http_upstream.h nginx-1.3.6-patched/src/http/ngx_http_upstream.h
+--- nginx-1.3.6/src/http/ngx_http_upstream.h	2011-11-01 22:18:10.000000000 +0800
++++ nginx-1.3.6-patched/src/http/ngx_http_upstream.h	2012-03-21 21:18:21.041237173 +0800
+@@ -313,6 +313,7 @@
+     unsigned                         buffering:1;
+ 
+     unsigned                         request_sent:1;
++    unsigned                         request_all_sent:1;
+     unsigned                         header_sent:1;
+ };
+ 

patches/nginx-1.3.7-allow_request_body_updating.patch

@@ -0,0 +1,128 @@
+diff '--exclude=*~' -ur nginx-1.3.7/src/http/ngx_http_core_module.c nginx-1.3.7-patched/src/http/ngx_http_core_module.c
+--- nginx-1.3.7/src/http/ngx_http_core_module.c	2012-06-04 04:58:12.000000000 -0700
++++ nginx-1.3.7-patched/src/http/ngx_http_core_module.c	2012-07-21 12:09:17.468576485 -0700
+@@ -2420,6 +2420,8 @@
+ 
+     sr->request_body = r->request_body;
+ 
++    sr->content_length_n = -1;
++
+     sr->method = NGX_HTTP_GET;
+     sr->http_version = r->http_version;
+ 
+diff '--exclude=*~' -ur nginx-1.3.7/src/http/ngx_http_request_body.c nginx-1.3.7-patched/src/http/ngx_http_request_body.c
+--- nginx-1.3.7/src/http/ngx_http_request_body.c	2012-04-12 12:35:41.000000000 -0700
++++ nginx-1.3.7-patched/src/http/ngx_http_request_body.c	2012-07-21 12:08:30.655376967 -0700
+@@ -39,7 +39,7 @@
+ 
+     r->main->count++;
+ 
+-    if (r->request_body || r->discard_body) {
++    if (r->request_body || r->discard_body || r->content_length_n == 0) {
+         post_handler(r);
+         return NGX_OK;
+     }
+@@ -441,7 +441,7 @@
+     ssize_t       size;
+     ngx_event_t  *rev;
+ 
+-    if (r != r->main || r->discard_body) {
++    if (r != r->main || r->discard_body || r->content_length_n == 0) {
+         return NGX_OK;
+     }
+ 
+@@ -457,20 +457,22 @@
+         ngx_del_timer(rev);
+     }
+ 
+-    if (r->headers_in.content_length_n <= 0 || r->request_body) {
++    r->content_length_n = r->headers_in.content_length_n;
++
++    if (r->content_length_n <= 0 || r->request_body) {
+         return NGX_OK;
+     }
+ 
+     size = r->header_in->last - r->header_in->pos;
+ 
+     if (size) {
+-        if (r->headers_in.content_length_n > size) {
++        if (r->content_length_n > size) {
+             r->header_in->pos += size;
+-            r->headers_in.content_length_n -= size;
++            r->content_length_n -= size;
+ 
+         } else {
+-            r->header_in->pos += (size_t) r->headers_in.content_length_n;
+-            r->headers_in.content_length_n = 0;
++            r->header_in->pos += (size_t) r->content_length_n;
++            r->content_length_n = 0;
+             return NGX_OK;
+         }
+     }
+@@ -569,7 +571,7 @@
+                    "http read discarded body");
+ 
+     for ( ;; ) {
+-        if (r->headers_in.content_length_n == 0) {
++        if (r->content_length_n == 0) {
+             r->read_event_handler = ngx_http_block_reading;
+             return NGX_OK;
+         }
+@@ -578,9 +580,9 @@
+             return NGX_AGAIN;
+         }
+ 
+-        size = (r->headers_in.content_length_n > NGX_HTTP_DISCARD_BUFFER_SIZE) ?
++        size = (r->content_length_n > NGX_HTTP_DISCARD_BUFFER_SIZE) ?
+                    NGX_HTTP_DISCARD_BUFFER_SIZE:
+-                   (size_t) r->headers_in.content_length_n;
++                   (size_t) r->content_length_n;
+ 
+         n = r->connection->recv(r->connection, buffer, size);
+ 
+@@ -597,7 +599,7 @@
+             return NGX_OK;
+         }
+ 
+-        r->headers_in.content_length_n -= n;
++        r->content_length_n -= n;
+     }
+ }
+ 
+Only in nginx-1.3.7-patched/src/http: ngx_http_request_body.c.orig
+diff '--exclude=*~' -ur nginx-1.3.7/src/http/ngx_http_request.c nginx-1.3.7-patched/src/http/ngx_http_request.c
+--- nginx-1.3.7/src/http/ngx_http_request.c	2012-06-05 06:52:37.000000000 -0700
++++ nginx-1.3.7-patched/src/http/ngx_http_request.c	2012-07-21 12:08:30.656376973 -0700
+@@ -287,6 +287,8 @@
+ 
+         r->pipeline = hc->pipeline;
+ 
++        r->content_length_n = -1;
++
+         if (hc->nbusy) {
+             r->header_in = hc->busy[0];
+         }
+@@ -298,6 +300,8 @@
+             return;
+         }
+ 
++        r->content_length_n = -1;
++
+         hc->request = r;
+     }
+ 
+Only in nginx-1.3.7-patched/src/http: ngx_http_request.c.orig
+diff '--exclude=*~' -ur nginx-1.3.7/src/http/ngx_http_request.h nginx-1.3.7-patched/src/http/ngx_http_request.h
+--- nginx-1.3.7/src/http/ngx_http_request.h	2012-02-28 06:54:23.000000000 -0800
++++ nginx-1.3.7-patched/src/http/ngx_http_request.h	2012-07-21 12:08:30.657376978 -0700
+@@ -368,6 +368,9 @@
+     ngx_pool_t                       *pool;
+     ngx_buf_t                        *header_in;
+ 
++    off_t                             content_length_n;
++                                          /* for discarding request body */
++
+     ngx_http_headers_in_t             headers_in;
+     ngx_http_headers_out_t            headers_out;
+ 
+Only in nginx-1.3.7-patched/src/http: ngx_http_request.h.orig

patches/nginx-1.3.7-channel-uninit-params.patch

@@ -0,0 +1,42 @@
+diff -urp nginx-1.3.7/src/os/unix/ngx_channel.c nginx-1.3.7-patched/src/os/unix/ngx_channel.c
+--- nginx-1.3.7/src/os/unix/ngx_channel.c	2012-01-18 07:07:43.000000000 -0800
++++ nginx-1.3.7-patched/src/os/unix/ngx_channel.c	2012-09-17 11:33:09.215394217 -0700
+@@ -31,6 +31,8 @@ ngx_write_channel(ngx_socket_t s, ngx_ch
+         msg.msg_controllen = 0;
+ 
+     } else {
++        ngx_memzero(&cmsg, sizeof(cmsg));
++
+         msg.msg_control = (caddr_t) &cmsg;
+         msg.msg_controllen = sizeof(cmsg);
+ 
+diff -urp nginx-1.3.7/src/os/unix/ngx_process_cycle.c nginx-1.3.7-patched/src/os/unix/ngx_process_cycle.c
+--- nginx-1.3.7/src/os/unix/ngx_process_cycle.c	2012-07-02 09:23:14.000000000 -0700
++++ nginx-1.3.7-patched/src/os/unix/ngx_process_cycle.c	2012-09-17 11:33:09.214394215 -0700
+@@ -356,6 +356,8 @@ ngx_start_worker_processes(ngx_cycle_t *
+ 
+     ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_OPEN_CHANNEL;
+ 
+     for (i = 0; i < n; i++) {
+@@ -463,6 +465,8 @@ ngx_signal_worker_processes(ngx_cycle_t
+     ngx_err_t      err;
+     ngx_channel_t  ch;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+ #if (NGX_BROKEN_SCM_RIGHTS)
+ 
+     ch.command = 0;
+@@ -564,6 +568,8 @@ ngx_reap_children(ngx_cycle_t *cycle)
+     ngx_channel_t     ch;
+     ngx_core_conf_t  *ccf;
+ 
++    ngx_memzero(&ch, sizeof(ngx_channel_t));
++
+     ch.command = NGX_CMD_CLOSE_CHANNEL;
+     ch.fd = -1;
+