unicorn 4.7.0 → 6.0.0

data/ext/unicorn_http/unicorn_http.c

@@ -27,86 +27,33 @@ void init_unicorn_httpdate(void);
 #define UH_FL_KAVERSION 0x80
 #define UH_FL_HASHEADER 0x100
 #define UH_FL_TO_CLEAR 0x200
+#define UH_FL_RESSTART 0x400 /* for check_client_connection */
+#define UH_FL_HIJACK 0x800
 
 /* all of these flags need to be set for keepalive to be supported */
 #define UH_FL_KEEPALIVE (UH_FL_KAVERSION | UH_FL_REQEOF | UH_FL_HASHEADER)
 
-/*
- * whether or not to trust X-Forwarded-Proto and X-Forwarded-SSL when
- * setting rack.url_scheme
- */
-static VALUE trust_x_forward = Qtrue;
-
-static unsigned long keepalive_requests = 100; /* same as nginx */
-
-/*
- * Returns the maximum number of keepalive requests a client may make
- * before the parser refuses to continue.
- */
-static VALUE ka_req(VALUE self)
-{
-  return ULONG2NUM(keepalive_requests);
-}
-
-/*
- * Sets the maximum number of keepalive requests a client may make.
- * A special value of +nil+ causes this to be the maximum value
- * possible (this is architecture-dependent).
- */
-static VALUE set_ka_req(VALUE self, VALUE val)
-{
-  keepalive_requests = NIL_P(val) ? ULONG_MAX : NUM2ULONG(val);
-
-  return ka_req(self);
-}
-
-/*
- * Sets whether or not the parser will trust X-Forwarded-Proto and
- * X-Forwarded-SSL headers and set "rack.url_scheme" to "https" accordingly.
- * Rainbows!/Zbatery installations facing untrusted clients directly
- * should set this to +false+
- */
-static VALUE set_xftrust(VALUE self, VALUE val)
-{
-  if (Qtrue == val || Qfalse == val)
-    trust_x_forward = val;
-  else
-    rb_raise(rb_eTypeError, "must be true or false");
-
-  return val;
-}
-
-/*
- * returns whether or not the parser will trust X-Forwarded-Proto and
- * X-Forwarded-SSL headers and set "rack.url_scheme" to "https" accordingly
- */
-static VALUE xftrust(VALUE self)
-{
-  return trust_x_forward;
-}
-
-static size_t MAX_HEADER_LEN = 1024 * (80 + 32); /* same as Mongrel */
+static unsigned int MAX_HEADER_LEN = 1024 * (80 + 32); /* same as Mongrel */
 
 /* this is only intended for use with Rainbows! */
 static VALUE set_maxhdrlen(VALUE self, VALUE len)
 {
-  return SIZET2NUM(MAX_HEADER_LEN = NUM2SIZET(len));
+  return UINT2NUM(MAX_HEADER_LEN = NUM2UINT(len));
 }
 
-/* keep this small for Rainbows! since every client has one */
+/* keep this small for other servers (e.g. yahns) since every client has one */
 struct http_parser {
   int cs; /* Ragel internal state */
   unsigned int flags;
-  unsigned long nr_requests;
-  size_t mark;
-  size_t offset;
+  unsigned int mark;
+  unsigned int offset;
   union { /* these 2 fields don't nest */
-    size_t field;
-    size_t query;
+    unsigned int field;
+    unsigned int query;
   } start;
   union {
-    size_t field_len; /* only used during header processing */
-    size_t dest_offset; /* only used during body processing */
+    unsigned int field_len; /* only used during header processing */
+    unsigned int dest_offset; /* only used during body processing */
   } s;
   VALUE buf;
   VALUE env;
@@ -117,7 +64,20 @@ struct http_parser {
   } len;
 };
 
-static ID id_clear, id_set_backtrace, id_response_start_sent;
+static ID id_set_backtrace, id_is_chunked_p;
+static VALUE cHttpParser;
+
+#ifdef HAVE_RB_HASH_CLEAR /* Ruby >= 2.0 */
+#  define my_hash_clear(h) (void)rb_hash_clear(h)
+#else /* !HAVE_RB_HASH_CLEAR - Ruby <= 1.9.3 */
+
+static ID id_clear;
+
+static void my_hash_clear(VALUE h)
+{
+  rb_funcall(h, id_clear, 0);
+}
+#endif /* HAVE_RB_HASH_CLEAR */
 
 static void finalize_header(struct http_parser *hp);
 
@@ -126,13 +86,25 @@ static void parser_raise(VALUE klass, const char *msg)
   VALUE exc = rb_exc_new2(klass, msg);
   VALUE bt = rb_ary_new();
 
-	rb_funcall(exc, id_set_backtrace, 1, bt);
-	rb_exc_raise(exc);
+  rb_funcall(exc, id_set_backtrace, 1, bt);
+  rb_exc_raise(exc);
+}
+
+static inline unsigned int ulong2uint(unsigned long n)
+{
+  unsigned int i = (unsigned int)n;
+
+  if (sizeof(unsigned int) != sizeof(unsigned long)) {
+    if ((unsigned long)i != n) {
+      rb_raise(rb_eRangeError, "too large to be 32-bit uint: %lu", n);
+    }
+  }
+  return i;
 }
 
 #define REMAINING (unsigned long)(pe - p)
-#define LEN(AT, FPC) (FPC - buffer - hp->AT)
-#define MARK(M,FPC) (hp->M = (FPC) - buffer)
+#define LEN(AT, FPC) (ulong2uint(FPC - buffer) - hp->AT)
+#define MARK(M,FPC) (hp->M = ulong2uint((FPC) - buffer))
 #define PTR_TO(F) (buffer + hp->F)
 #define STR_NEW(M,FPC) rb_str_new(PTR_TO(M), LEN(M, FPC))
 #define STRIPPED_STR_NEW(M,FPC) stripped_str_new(PTR_TO(M), LEN(M, FPC))
@@ -251,6 +223,19 @@ static void write_cont_value(struct http_parser *hp,
   rb_str_buf_cat(hp->cont, vptr, end + 1);
 }
 
+static int is_chunked(VALUE v)
+{
+  /* common case first */
+  if (STR_CSTR_CASE_EQ(v, "chunked"))
+    return 1;
+
+  /*
+   * call Ruby function in unicorn/http_request.rb to deal with unlikely
+   * comma-delimited case
+   */
+  return rb_funcall(cHttpParser, id_is_chunked_p, 1, v) != Qfalse;
+}
+
 static void write_value(struct http_parser *hp,
                         const char *buffer, const char *p)
 {
@@ -277,7 +262,9 @@ static void write_value(struct http_parser *hp,
     f = uncommon_field(field, flen);
   } else if (f == g_http_connection) {
     hp_keepalive_connection(hp, v);
-  } else if (f == g_content_length) {
+  } else if (f == g_content_length && !HP_FL_TEST(hp, CHUNKED)) {
+    if (hp->len.content)
+      parser_raise(eHttpParserError, "Content-Length already set");
     hp->len.content = parse_length(RSTRING_PTR(v), RSTRING_LEN(v));
     if (hp->len.content < 0)
       parser_raise(eHttpParserError, "invalid Content-Length");
@@ -285,9 +272,30 @@ static void write_value(struct http_parser *hp,
       HP_FL_SET(hp, HASBODY);
     hp_invalid_if_trailer(hp);
   } else if (f == g_http_transfer_encoding) {
-    if (STR_CSTR_CASE_EQ(v, "chunked")) {
+    if (is_chunked(v)) {
+      if (HP_FL_TEST(hp, CHUNKED))
+        /*
+         * RFC 7230 3.3.1:
+         * A sender MUST NOT apply chunked more than once to a message body
+         * (i.e., chunking an already chunked message is not allowed).
+         */
+        parser_raise(eHttpParserError, "Transfer-Encoding double chunked");
+
       HP_FL_SET(hp, CHUNKED);
       HP_FL_SET(hp, HASBODY);
+
+      /* RFC 7230 3.3.3, 3: favor chunked if Content-Length exists */
+      hp->len.content = 0;
+    } else if (HP_FL_TEST(hp, CHUNKED)) {
+      /*
+       * RFC 7230 3.3.3, point 3 states:
+       * If a Transfer-Encoding header field is present in a request and
+       * the chunked transfer coding is not the final encoding, the
+       * message body length cannot be determined reliably; the server
+       * MUST respond with the 400 (Bad Request) status code and then
+       * close the connection.
+       */
+      parser_raise(eHttpParserError, "invalid Transfer-Encoding");
     }
     hp_invalid_if_trailer(hp);
   } else if (f == g_http_trailer) {
@@ -316,23 +324,23 @@ static void write_value(struct http_parser *hp,
 /** Machine **/
 
 
-#line 423 "unicorn_http.rl"
+#line 431 "unicorn_http.rl"
 
 
 /** Data **/
 
-#line 325 "unicorn_http.c"
+#line 333 "unicorn_http.c"
 static const int http_parser_start = 1;
 static const int http_parser_first_final = 122;
 static const int http_parser_error = 0;
 
 static const int http_parser_en_ChunkedBody = 100;
-static const int http_parser_en_ChunkedBody_chunk_chunk_end = 106;
+static const int http_parser_en_ChunkedBody_chunk_chunk_end = 105;
 static const int http_parser_en_Trailers = 114;
 static const int http_parser_en_main = 1;
 
 
-#line 427 "unicorn_http.rl"
+#line 435 "unicorn_http.rl"
 
 static void http_parser_init(struct http_parser *hp)
 {
@@ -345,12 +353,12 @@ static void http_parser_init(struct http_parser *hp)
   hp->len.content = 0;
   hp->cont = Qfalse; /* zero on MRI, should be optimized away by above */
   
-#line 349 "unicorn_http.c"
+#line 357 "unicorn_http.c"
 	{
 	cs = http_parser_start;
 	}
 
-#line 439 "unicorn_http.rl"
+#line 447 "unicorn_http.rl"
   hp->cs = cs;
 }
 
@@ -378,7 +386,7 @@ http_parser_execute(struct http_parser *hp, char *buffer, size_t len)
     goto skip_chunk_data_hack;
   }
   
-#line 382 "unicorn_http.c"
+#line 390 "unicorn_http.c"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -413,14 +421,14 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 319 "unicorn_http.rl"
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 424 "unicorn_http.c"
+#line 432 "unicorn_http.c"
 	switch( (*p) ) {
 		case 32: goto tr3;
 		case 33: goto st49;
@@ -446,14 +454,14 @@ case 2:
 		goto st49;
 	goto st0;
 tr3:
-#line 328 "unicorn_http.rl"
+#line 336 "unicorn_http.rl"
 	{ request_method(hp, PTR_TO(mark), LEN(mark, p)); }
 	goto st3;
 st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 457 "unicorn_http.c"
+#line 465 "unicorn_http.c"
 	switch( (*p) ) {
 		case 42: goto tr5;
 		case 47: goto tr6;
@@ -462,21 +470,21 @@ case 3:
 	}
 	goto st0;
 tr5:
-#line 319 "unicorn_http.rl"
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 473 "unicorn_http.c"
+#line 481 "unicorn_http.c"
 	switch( (*p) ) {
 		case 32: goto tr8;
 		case 35: goto tr9;
 	}
 	goto st0;
 tr8:
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -493,24 +501,24 @@ tr8:
     }
   }
 	goto st5;
-tr37:
-#line 319 "unicorn_http.rl"
+tr42:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
-#line 348 "unicorn_http.rl"
+#line 356 "unicorn_http.rl"
 	{
     VALIDATE_MAX_URI_LENGTH(LEN(mark, p), FRAGMENT);
     rb_hash_aset(hp->env, g_fragment, STR_NEW(mark, p));
   }
 	goto st5;
-tr40:
-#line 348 "unicorn_http.rl"
+tr45:
+#line 356 "unicorn_http.rl"
 	{
     VALIDATE_MAX_URI_LENGTH(LEN(mark, p), FRAGMENT);
     rb_hash_aset(hp->env, g_fragment, STR_NEW(mark, p));
   }
 	goto st5;
-tr44:
-#line 358 "unicorn_http.rl"
+tr49:
+#line 366 "unicorn_http.rl"
 	{
     VALUE val;
 
@@ -521,7 +529,7 @@ tr44:
     if (!STR_CSTR_EQ(val, "*"))
       rb_hash_aset(hp->env, g_path_info, val);
   }
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -538,15 +546,15 @@ tr44:
     }
   }
 	goto st5;
-tr50:
-#line 352 "unicorn_http.rl"
+tr55:
+#line 360 "unicorn_http.rl"
 	{MARK(start.query, p); }
-#line 353 "unicorn_http.rl"
+#line 361 "unicorn_http.rl"
 	{
     VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -563,13 +571,13 @@ tr50:
     }
   }
 	goto st5;
-tr54:
-#line 353 "unicorn_http.rl"
+tr59:
+#line 361 "unicorn_http.rl"
 	{
     VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -590,19 +598,19 @@ st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 594 "unicorn_http.c"
+#line 602 "unicorn_http.c"
 	if ( (*p) == 72 )
 		goto tr10;
 	goto st0;
 tr10:
-#line 319 "unicorn_http.rl"
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st6;
 st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 606 "unicorn_http.c"
+#line 614 "unicorn_http.c"
 	if ( (*p) == 84 )
 		goto st7;
 	goto st0;
@@ -654,112 +662,163 @@ st13:
 	if ( ++p == pe )
 		goto _test_eof13;
 case 13:
-	if ( (*p) == 13 )
-		goto tr18;
+	switch( (*p) ) {
+		case 10: goto tr18;
+		case 13: goto tr19;
+	}
 	if ( 48 <= (*p) && (*p) <= 57 )
 		goto st13;
 	goto st0;
 tr18:
-#line 357 "unicorn_http.rl"
+#line 365 "unicorn_http.rl"
 	{ http_version(hp, PTR_TO(mark), LEN(mark, p)); }
 	goto st14;
-tr25:
-#line 325 "unicorn_http.rl"
+tr26:
+#line 333 "unicorn_http.rl"
 	{ MARK(mark, p); }
-#line 327 "unicorn_http.rl"
+#line 335 "unicorn_http.rl"
 	{ write_cont_value(hp, buffer, p); }
 	goto st14;
-tr27:
-#line 327 "unicorn_http.rl"
+tr29:
+#line 335 "unicorn_http.rl"
 	{ write_cont_value(hp, buffer, p); }
 	goto st14;
-tr33:
-#line 325 "unicorn_http.rl"
+tr36:
+#line 333 "unicorn_http.rl"
 	{ MARK(mark, p); }
-#line 326 "unicorn_http.rl"
+#line 334 "unicorn_http.rl"
 	{ write_value(hp, buffer, p); }
 	goto st14;
-tr35:
-#line 326 "unicorn_http.rl"
+tr39:
+#line 334 "unicorn_http.rl"
 	{ write_value(hp, buffer, p); }
 	goto st14;
 st14:
 	if ( ++p == pe )
 		goto _test_eof14;
 case 14:
-#line 691 "unicorn_http.c"
-	if ( (*p) == 10 )
-		goto st15;
-	goto st0;
-st15:
-	if ( ++p == pe )
-		goto _test_eof15;
-case 15:
+#line 701 "unicorn_http.c"
 	switch( (*p) ) {
-		case 9: goto st16;
+		case 9: goto st15;
+		case 10: goto tr21;
 		case 13: goto st18;
-		case 32: goto st16;
-		case 33: goto tr22;
-		case 124: goto tr22;
-		case 126: goto tr22;
+		case 32: goto st15;
+		case 33: goto tr23;
+		case 124: goto tr23;
+		case 126: goto tr23;
 	}
 	if ( (*p) < 45 ) {
 		if ( (*p) > 39 ) {
 			if ( 42 <= (*p) && (*p) <= 43 )
-				goto tr22;
+				goto tr23;
 		} else if ( (*p) >= 35 )
-			goto tr22;
+			goto tr23;
 	} else if ( (*p) > 46 ) {
 		if ( (*p) < 65 ) {
 			if ( 48 <= (*p) && (*p) <= 57 )
-				goto tr22;
+				goto tr23;
 		} else if ( (*p) > 90 ) {
 			if ( 94 <= (*p) && (*p) <= 122 )
-				goto tr22;
+				goto tr23;
 		} else
-			goto tr22;
+			goto tr23;
 	} else
-		goto tr22;
+		goto tr23;
 	goto st0;
-tr24:
-#line 325 "unicorn_http.rl"
+tr25:
+#line 333 "unicorn_http.rl"
 	{ MARK(mark, p); }
-	goto st16;
-st16:
+	goto st15;
+st15:
 	if ( ++p == pe )
-		goto _test_eof16;
-case 16:
-#line 733 "unicorn_http.c"
+		goto _test_eof15;
+case 15:
+#line 737 "unicorn_http.c"
 	switch( (*p) ) {
-		case 9: goto tr24;
-		case 13: goto tr25;
-		case 32: goto tr24;
+		case 9: goto tr25;
+		case 10: goto tr26;
+		case 13: goto tr27;
+		case 32: goto tr25;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto tr23;
-tr23:
-#line 325 "unicorn_http.rl"
+	goto tr24;
+tr24:
+#line 333 "unicorn_http.rl"
 	{ MARK(mark, p); }
-	goto st17;
-st17:
+	goto st16;
+st16:
 	if ( ++p == pe )
-		goto _test_eof17;
-case 17:
-#line 751 "unicorn_http.c"
+		goto _test_eof16;
+case 16:
+#line 756 "unicorn_http.c"
 	switch( (*p) ) {
-		case 13: goto tr27;
+		case 10: goto tr29;
+		case 13: goto tr30;
 		case 127: goto st0;
 	}
 	if ( (*p) > 8 ) {
-		if ( 10 <= (*p) && (*p) <= 31 )
+		if ( 11 <= (*p) && (*p) <= 31 )
 			goto st0;
 	} else if ( (*p) >= 0 )
 		goto st0;
+	goto st16;
+tr19:
+#line 365 "unicorn_http.rl"
+	{ http_version(hp, PTR_TO(mark), LEN(mark, p)); }
+	goto st17;
+tr27:
+#line 333 "unicorn_http.rl"
+	{ MARK(mark, p); }
+#line 335 "unicorn_http.rl"
+	{ write_cont_value(hp, buffer, p); }
+	goto st17;
+tr30:
+#line 335 "unicorn_http.rl"
+	{ write_cont_value(hp, buffer, p); }
 	goto st17;
-tr99:
+tr37:
 #line 333 "unicorn_http.rl"
+	{ MARK(mark, p); }
+#line 334 "unicorn_http.rl"
+	{ write_value(hp, buffer, p); }
+	goto st17;
+tr40:
+#line 334 "unicorn_http.rl"
+	{ write_value(hp, buffer, p); }
+	goto st17;
+st17:
+	if ( ++p == pe )
+		goto _test_eof17;
+case 17:
+#line 796 "unicorn_http.c"
+	if ( (*p) == 10 )
+		goto st14;
+	goto st0;
+tr21:
+#line 381 "unicorn_http.rl"
+	{
+    finalize_header(hp);
+
+    cs = http_parser_first_final;
+    if (HP_FL_TEST(hp, HASBODY)) {
+      HP_FL_SET(hp, INBODY);
+      if (HP_FL_TEST(hp, CHUNKED))
+        cs = http_parser_en_ChunkedBody;
+    } else {
+      HP_FL_SET(hp, REQEOF);
+      assert(!HP_FL_TEST(hp, CHUNKED) && "chunked encoding without body!");
+    }
+    /*
+     * go back to Ruby so we can call the Rack application, we'll reenter
+     * the parser iff the body needs to be processed.
+     */
+    goto post_exec;
+  }
+	goto st122;
+tr104:
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -775,25 +834,82 @@ tr99:
       rb_hash_aset(hp->env, g_request_path, str);
     }
   }
-	goto st18;
-tr102:
-#line 319 "unicorn_http.rl"
+#line 381 "unicorn_http.rl"
+	{
+    finalize_header(hp);
+
+    cs = http_parser_first_final;
+    if (HP_FL_TEST(hp, HASBODY)) {
+      HP_FL_SET(hp, INBODY);
+      if (HP_FL_TEST(hp, CHUNKED))
+        cs = http_parser_en_ChunkedBody;
+    } else {
+      HP_FL_SET(hp, REQEOF);
+      assert(!HP_FL_TEST(hp, CHUNKED) && "chunked encoding without body!");
+    }
+    /*
+     * go back to Ruby so we can call the Rack application, we'll reenter
+     * the parser iff the body needs to be processed.
+     */
+    goto post_exec;
+  }
+	goto st122;
+tr108:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
-#line 348 "unicorn_http.rl"
+#line 356 "unicorn_http.rl"
 	{
     VALIDATE_MAX_URI_LENGTH(LEN(mark, p), FRAGMENT);
     rb_hash_aset(hp->env, g_fragment, STR_NEW(mark, p));
   }
-	goto st18;
-tr105:
-#line 348 "unicorn_http.rl"
+#line 381 "unicorn_http.rl"
+	{
+    finalize_header(hp);
+
+    cs = http_parser_first_final;
+    if (HP_FL_TEST(hp, HASBODY)) {
+      HP_FL_SET(hp, INBODY);
+      if (HP_FL_TEST(hp, CHUNKED))
+        cs = http_parser_en_ChunkedBody;
+    } else {
+      HP_FL_SET(hp, REQEOF);
+      assert(!HP_FL_TEST(hp, CHUNKED) && "chunked encoding without body!");
+    }
+    /*
+     * go back to Ruby so we can call the Rack application, we'll reenter
+     * the parser iff the body needs to be processed.
+     */
+    goto post_exec;
+  }
+	goto st122;
+tr112:
+#line 356 "unicorn_http.rl"
 	{
     VALIDATE_MAX_URI_LENGTH(LEN(mark, p), FRAGMENT);
     rb_hash_aset(hp->env, g_fragment, STR_NEW(mark, p));
   }
-	goto st18;
-tr109:
-#line 358 "unicorn_http.rl"
+#line 381 "unicorn_http.rl"
+	{
+    finalize_header(hp);
+
+    cs = http_parser_first_final;
+    if (HP_FL_TEST(hp, HASBODY)) {
+      HP_FL_SET(hp, INBODY);
+      if (HP_FL_TEST(hp, CHUNKED))
+        cs = http_parser_en_ChunkedBody;
+    } else {
+      HP_FL_SET(hp, REQEOF);
+      assert(!HP_FL_TEST(hp, CHUNKED) && "chunked encoding without body!");
+    }
+    /*
+     * go back to Ruby so we can call the Rack application, we'll reenter
+     * the parser iff the body needs to be processed.
+     */
+    goto post_exec;
+  }
+	goto st122;
+tr117:
+#line 366 "unicorn_http.rl"
 	{
     VALUE val;
 
@@ -804,7 +920,7 @@ tr109:
     if (!STR_CSTR_EQ(val, "*"))
       rb_hash_aset(hp->env, g_path_info, val);
   }
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -820,16 +936,35 @@ tr109:
       rb_hash_aset(hp->env, g_request_path, str);
     }
   }
-	goto st18;
-tr115:
-#line 352 "unicorn_http.rl"
+#line 381 "unicorn_http.rl"
+	{
+    finalize_header(hp);
+
+    cs = http_parser_first_final;
+    if (HP_FL_TEST(hp, HASBODY)) {
+      HP_FL_SET(hp, INBODY);
+      if (HP_FL_TEST(hp, CHUNKED))
+        cs = http_parser_en_ChunkedBody;
+    } else {
+      HP_FL_SET(hp, REQEOF);
+      assert(!HP_FL_TEST(hp, CHUNKED) && "chunked encoding without body!");
+    }
+    /*
+     * go back to Ruby so we can call the Rack application, we'll reenter
+     * the parser iff the body needs to be processed.
+     */
+    goto post_exec;
+  }
+	goto st122;
+tr124:
+#line 360 "unicorn_http.rl"
 	{MARK(start.query, p); }
-#line 353 "unicorn_http.rl"
+#line 361 "unicorn_http.rl"
 	{
     VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -845,14 +980,33 @@ tr115:
       rb_hash_aset(hp->env, g_request_path, str);
     }
   }
-	goto st18;
-tr119:
-#line 353 "unicorn_http.rl"
+#line 381 "unicorn_http.rl"
+	{
+    finalize_header(hp);
+
+    cs = http_parser_first_final;
+    if (HP_FL_TEST(hp, HASBODY)) {
+      HP_FL_SET(hp, INBODY);
+      if (HP_FL_TEST(hp, CHUNKED))
+        cs = http_parser_en_ChunkedBody;
+    } else {
+      HP_FL_SET(hp, REQEOF);
+      assert(!HP_FL_TEST(hp, CHUNKED) && "chunked encoding without body!");
+    }
+    /*
+     * go back to Ruby so we can call the Rack application, we'll reenter
+     * the parser iff the body needs to be processed.
+     */
+    goto post_exec;
+  }
+	goto st122;
+tr129:
+#line 361 "unicorn_http.rl"
 	{
     VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -868,17 +1022,7 @@ tr119:
       rb_hash_aset(hp->env, g_request_path, str);
     }
   }
-	goto st18;
-st18:
-	if ( ++p == pe )
-		goto _test_eof18;
-case 18:
-#line 877 "unicorn_http.c"
-	if ( (*p) == 10 )
-		goto tr28;
-	goto st0;
-tr28:
-#line 373 "unicorn_http.rl"
+#line 381 "unicorn_http.rl"
 	{
     finalize_header(hp);
 
@@ -892,100 +1036,221 @@ tr28:
       assert(!HP_FL_TEST(hp, CHUNKED) && "chunked encoding without body!");
     }
     /*
-     * go back to Ruby so we can call the Rack application, we'll reenter
-     * the parser iff the body needs to be processed.
+     * go back to Ruby so we can call the Rack application, we'll reenter
+     * the parser iff the body needs to be processed.
+     */
+    goto post_exec;
+  }
+	goto st122;
+st122:
+	if ( ++p == pe )
+		goto _test_eof122;
+case 122:
+#line 1050 "unicorn_http.c"
+	goto st0;
+tr105:
+#line 341 "unicorn_http.rl"
+	{
+    VALUE str;
+
+    VALIDATE_MAX_URI_LENGTH(LEN(mark, p), REQUEST_URI);
+    str = rb_hash_aset(hp->env, g_request_uri, STR_NEW(mark, p));
+    /*
+     * "OPTIONS * HTTP/1.1\r\n" is a valid request, but we can't have '*'
+     * in REQUEST_PATH or PATH_INFO or else Rack::Lint will complain
+     */
+    if (STR_CSTR_EQ(str, "*")) {
+      str = rb_str_new(NULL, 0);
+      rb_hash_aset(hp->env, g_path_info, str);
+      rb_hash_aset(hp->env, g_request_path, str);
+    }
+  }
+	goto st18;
+tr109:
+#line 327 "unicorn_http.rl"
+	{MARK(mark, p); }
+#line 356 "unicorn_http.rl"
+	{
+    VALIDATE_MAX_URI_LENGTH(LEN(mark, p), FRAGMENT);
+    rb_hash_aset(hp->env, g_fragment, STR_NEW(mark, p));
+  }
+	goto st18;
+tr113:
+#line 356 "unicorn_http.rl"
+	{
+    VALIDATE_MAX_URI_LENGTH(LEN(mark, p), FRAGMENT);
+    rb_hash_aset(hp->env, g_fragment, STR_NEW(mark, p));
+  }
+	goto st18;
+tr118:
+#line 366 "unicorn_http.rl"
+	{
+    VALUE val;
+
+    VALIDATE_MAX_URI_LENGTH(LEN(mark, p), REQUEST_PATH);
+    val = rb_hash_aset(hp->env, g_request_path, STR_NEW(mark, p));
+
+    /* rack says PATH_INFO must start with "/" or be empty */
+    if (!STR_CSTR_EQ(val, "*"))
+      rb_hash_aset(hp->env, g_path_info, val);
+  }
+#line 341 "unicorn_http.rl"
+	{
+    VALUE str;
+
+    VALIDATE_MAX_URI_LENGTH(LEN(mark, p), REQUEST_URI);
+    str = rb_hash_aset(hp->env, g_request_uri, STR_NEW(mark, p));
+    /*
+     * "OPTIONS * HTTP/1.1\r\n" is a valid request, but we can't have '*'
+     * in REQUEST_PATH or PATH_INFO or else Rack::Lint will complain
+     */
+    if (STR_CSTR_EQ(str, "*")) {
+      str = rb_str_new(NULL, 0);
+      rb_hash_aset(hp->env, g_path_info, str);
+      rb_hash_aset(hp->env, g_request_path, str);
+    }
+  }
+	goto st18;
+tr125:
+#line 360 "unicorn_http.rl"
+	{MARK(start.query, p); }
+#line 361 "unicorn_http.rl"
+	{
+    VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
+    rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
+  }
+#line 341 "unicorn_http.rl"
+	{
+    VALUE str;
+
+    VALIDATE_MAX_URI_LENGTH(LEN(mark, p), REQUEST_URI);
+    str = rb_hash_aset(hp->env, g_request_uri, STR_NEW(mark, p));
+    /*
+     * "OPTIONS * HTTP/1.1\r\n" is a valid request, but we can't have '*'
+     * in REQUEST_PATH or PATH_INFO or else Rack::Lint will complain
+     */
+    if (STR_CSTR_EQ(str, "*")) {
+      str = rb_str_new(NULL, 0);
+      rb_hash_aset(hp->env, g_path_info, str);
+      rb_hash_aset(hp->env, g_request_path, str);
+    }
+  }
+	goto st18;
+tr130:
+#line 361 "unicorn_http.rl"
+	{
+    VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
+    rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
+  }
+#line 341 "unicorn_http.rl"
+	{
+    VALUE str;
+
+    VALIDATE_MAX_URI_LENGTH(LEN(mark, p), REQUEST_URI);
+    str = rb_hash_aset(hp->env, g_request_uri, STR_NEW(mark, p));
+    /*
+     * "OPTIONS * HTTP/1.1\r\n" is a valid request, but we can't have '*'
+     * in REQUEST_PATH or PATH_INFO or else Rack::Lint will complain
      */
-    goto post_exec;
+    if (STR_CSTR_EQ(str, "*")) {
+      str = rb_str_new(NULL, 0);
+      rb_hash_aset(hp->env, g_path_info, str);
+      rb_hash_aset(hp->env, g_request_path, str);
+    }
   }
-	goto st122;
-st122:
+	goto st18;
+st18:
 	if ( ++p == pe )
-		goto _test_eof122;
-case 122:
-#line 906 "unicorn_http.c"
+		goto _test_eof18;
+case 18:
+#line 1167 "unicorn_http.c"
+	if ( (*p) == 10 )
+		goto tr21;
 	goto st0;
-tr22:
-#line 321 "unicorn_http.rl"
+tr23:
+#line 329 "unicorn_http.rl"
 	{ MARK(start.field, p); }
-#line 322 "unicorn_http.rl"
+#line 330 "unicorn_http.rl"
 	{ snake_upcase_char(deconst(p)); }
 	goto st19;
-tr29:
-#line 322 "unicorn_http.rl"
+tr32:
+#line 330 "unicorn_http.rl"
 	{ snake_upcase_char(deconst(p)); }
 	goto st19;
 st19:
 	if ( ++p == pe )
 		goto _test_eof19;
 case 19:
-#line 922 "unicorn_http.c"
+#line 1185 "unicorn_http.c"
 	switch( (*p) ) {
-		case 33: goto tr29;
-		case 58: goto tr30;
-		case 124: goto tr29;
-		case 126: goto tr29;
+		case 33: goto tr32;
+		case 58: goto tr33;
+		case 124: goto tr32;
+		case 126: goto tr32;
 	}
 	if ( (*p) < 45 ) {
 		if ( (*p) > 39 ) {
 			if ( 42 <= (*p) && (*p) <= 43 )
-				goto tr29;
+				goto tr32;
 		} else if ( (*p) >= 35 )
-			goto tr29;
+			goto tr32;
 	} else if ( (*p) > 46 ) {
 		if ( (*p) < 65 ) {
 			if ( 48 <= (*p) && (*p) <= 57 )
-				goto tr29;
+				goto tr32;
 		} else if ( (*p) > 90 ) {
 			if ( 94 <= (*p) && (*p) <= 122 )
-				goto tr29;
+				goto tr32;
 		} else
-			goto tr29;
+			goto tr32;
 	} else
-		goto tr29;
+		goto tr32;
 	goto st0;
-tr32:
-#line 325 "unicorn_http.rl"
+tr35:
+#line 333 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st20;
-tr30:
-#line 324 "unicorn_http.rl"
+tr33:
+#line 332 "unicorn_http.rl"
 	{ hp->s.field_len = LEN(start.field, p); }
 	goto st20;
 st20:
 	if ( ++p == pe )
 		goto _test_eof20;
 case 20:
-#line 959 "unicorn_http.c"
+#line 1222 "unicorn_http.c"
 	switch( (*p) ) {
-		case 9: goto tr32;
-		case 13: goto tr33;
-		case 32: goto tr32;
+		case 9: goto tr35;
+		case 10: goto tr36;
+		case 13: goto tr37;
+		case 32: goto tr35;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto tr31;
-tr31:
-#line 325 "unicorn_http.rl"
+	goto tr34;
+tr34:
+#line 333 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st21;
 st21:
 	if ( ++p == pe )
 		goto _test_eof21;
 case 21:
-#line 977 "unicorn_http.c"
+#line 1241 "unicorn_http.c"
 	switch( (*p) ) {
-		case 13: goto tr35;
+		case 10: goto tr39;
+		case 13: goto tr40;
 		case 127: goto st0;
 	}
 	if ( (*p) > 8 ) {
-		if ( 10 <= (*p) && (*p) <= 31 )
+		if ( 11 <= (*p) && (*p) <= 31 )
 			goto st0;
 	} else if ( (*p) >= 0 )
 		goto st0;
 	goto st21;
 tr9:
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -1002,8 +1267,8 @@ tr9:
     }
   }
 	goto st22;
-tr45:
-#line 358 "unicorn_http.rl"
+tr50:
+#line 366 "unicorn_http.rl"
 	{
     VALUE val;
 
@@ -1014,7 +1279,7 @@ tr45:
     if (!STR_CSTR_EQ(val, "*"))
       rb_hash_aset(hp->env, g_path_info, val);
   }
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -1031,15 +1296,15 @@ tr45:
     }
   }
 	goto st22;
-tr51:
-#line 352 "unicorn_http.rl"
+tr56:
+#line 360 "unicorn_http.rl"
 	{MARK(start.query, p); }
-#line 353 "unicorn_http.rl"
+#line 361 "unicorn_http.rl"
 	{
     VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -1056,13 +1321,13 @@ tr51:
     }
   }
 	goto st22;
-tr55:
-#line 353 "unicorn_http.rl"
+tr60:
+#line 361 "unicorn_http.rl"
 	{
     VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -1083,27 +1348,27 @@ st22:
 	if ( ++p == pe )
 		goto _test_eof22;
 case 22:
-#line 1087 "unicorn_http.c"
+#line 1352 "unicorn_http.c"
 	switch( (*p) ) {
-		case 32: goto tr37;
+		case 32: goto tr42;
 		case 35: goto st0;
-		case 37: goto tr38;
+		case 37: goto tr43;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto tr36;
-tr36:
-#line 319 "unicorn_http.rl"
+	goto tr41;
+tr41:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st23;
 st23:
 	if ( ++p == pe )
 		goto _test_eof23;
 case 23:
-#line 1105 "unicorn_http.c"
+#line 1370 "unicorn_http.c"
 	switch( (*p) ) {
-		case 32: goto tr40;
+		case 32: goto tr45;
 		case 35: goto st0;
 		case 37: goto st24;
 		case 127: goto st0;
@@ -1111,15 +1376,15 @@ case 23:
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
 	goto st23;
-tr38:
-#line 319 "unicorn_http.rl"
+tr43:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st24;
 st24:
 	if ( ++p == pe )
 		goto _test_eof24;
 case 24:
-#line 1123 "unicorn_http.c"
+#line 1388 "unicorn_http.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto st25;
@@ -1143,25 +1408,25 @@ case 25:
 		goto st23;
 	goto st0;
 tr6:
-#line 319 "unicorn_http.rl"
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st26;
-tr71:
-#line 332 "unicorn_http.rl"
+tr76:
+#line 340 "unicorn_http.rl"
 	{ rb_hash_aset(hp->env, g_http_host, STR_NEW(mark, p)); }
-#line 319 "unicorn_http.rl"
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st26;
 st26:
 	if ( ++p == pe )
 		goto _test_eof26;
 case 26:
-#line 1160 "unicorn_http.c"
+#line 1425 "unicorn_http.c"
 	switch( (*p) ) {
-		case 32: goto tr44;
-		case 35: goto tr45;
+		case 32: goto tr49;
+		case 35: goto tr50;
 		case 37: goto st27;
-		case 63: goto tr47;
+		case 63: goto tr52;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
@@ -1193,8 +1458,8 @@ case 28:
 	} else
 		goto st26;
 	goto st0;
-tr47:
-#line 358 "unicorn_http.rl"
+tr52:
+#line 366 "unicorn_http.rl"
 	{
     VALUE val;
 
@@ -1210,43 +1475,43 @@ st29:
 	if ( ++p == pe )
 		goto _test_eof29;
 case 29:
-#line 1214 "unicorn_http.c"
+#line 1479 "unicorn_http.c"
 	switch( (*p) ) {
-		case 32: goto tr50;
-		case 35: goto tr51;
-		case 37: goto tr52;
+		case 32: goto tr55;
+		case 35: goto tr56;
+		case 37: goto tr57;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto tr49;
-tr49:
-#line 352 "unicorn_http.rl"
+	goto tr54;
+tr54:
+#line 360 "unicorn_http.rl"
 	{MARK(start.query, p); }
 	goto st30;
 st30:
 	if ( ++p == pe )
 		goto _test_eof30;
 case 30:
-#line 1232 "unicorn_http.c"
+#line 1497 "unicorn_http.c"
 	switch( (*p) ) {
-		case 32: goto tr54;
-		case 35: goto tr55;
+		case 32: goto tr59;
+		case 35: goto tr60;
 		case 37: goto st31;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
 	goto st30;
-tr52:
-#line 352 "unicorn_http.rl"
+tr57:
+#line 360 "unicorn_http.rl"
 	{MARK(start.query, p); }
 	goto st31;
 st31:
 	if ( ++p == pe )
 		goto _test_eof31;
 case 31:
-#line 1250 "unicorn_http.c"
+#line 1515 "unicorn_http.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto st32;
@@ -1270,66 +1535,66 @@ case 32:
 		goto st30;
 	goto st0;
 tr7:
-#line 319 "unicorn_http.rl"
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
-#line 323 "unicorn_http.rl"
+#line 331 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st33;
 st33:
 	if ( ++p == pe )
 		goto _test_eof33;
 case 33:
-#line 1283 "unicorn_http.c"
+#line 1548 "unicorn_http.c"
 	switch( (*p) ) {
-		case 84: goto tr58;
-		case 116: goto tr58;
+		case 84: goto tr63;
+		case 116: goto tr63;
 	}
 	goto st0;
-tr58:
-#line 323 "unicorn_http.rl"
+tr63:
+#line 331 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st34;
 st34:
 	if ( ++p == pe )
 		goto _test_eof34;
 case 34:
-#line 1297 "unicorn_http.c"
+#line 1562 "unicorn_http.c"
 	switch( (*p) ) {
-		case 84: goto tr59;
-		case 116: goto tr59;
+		case 84: goto tr64;
+		case 116: goto tr64;
 	}
 	goto st0;
-tr59:
-#line 323 "unicorn_http.rl"
+tr64:
+#line 331 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st35;
 st35:
 	if ( ++p == pe )
 		goto _test_eof35;
 case 35:
-#line 1311 "unicorn_http.c"
+#line 1576 "unicorn_http.c"
 	switch( (*p) ) {
-		case 80: goto tr60;
-		case 112: goto tr60;
+		case 80: goto tr65;
+		case 112: goto tr65;
 	}
 	goto st0;
-tr60:
-#line 323 "unicorn_http.rl"
+tr65:
+#line 331 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st36;
 st36:
 	if ( ++p == pe )
 		goto _test_eof36;
 case 36:
-#line 1325 "unicorn_http.c"
+#line 1590 "unicorn_http.c"
 	switch( (*p) ) {
-		case 58: goto tr61;
-		case 83: goto tr62;
-		case 115: goto tr62;
+		case 58: goto tr66;
+		case 83: goto tr67;
+		case 115: goto tr67;
 	}
 	goto st0;
-tr61:
-#line 329 "unicorn_http.rl"
+tr66:
+#line 337 "unicorn_http.rl"
 	{
     rb_hash_aset(hp->env, g_rack_url_scheme, STR_NEW(mark, p));
   }
@@ -1338,7 +1603,7 @@ st37:
 	if ( ++p == pe )
 		goto _test_eof37;
 case 37:
-#line 1342 "unicorn_http.c"
+#line 1607 "unicorn_http.c"
 	if ( (*p) == 47 )
 		goto st38;
 	goto st0;
@@ -1357,8 +1622,8 @@ case 39:
 		case 37: goto st41;
 		case 47: goto st0;
 		case 60: goto st0;
-		case 91: goto tr68;
-		case 95: goto tr67;
+		case 91: goto tr73;
+		case 95: goto tr72;
 		case 127: goto st0;
 	}
 	if ( (*p) < 45 ) {
@@ -1373,11 +1638,11 @@ case 39:
 				goto st0;
 		} else if ( (*p) > 90 ) {
 			if ( 97 <= (*p) && (*p) <= 122 )
-				goto tr67;
+				goto tr72;
 		} else
-			goto tr67;
+			goto tr72;
 	} else
-		goto tr67;
+		goto tr72;
 	goto st40;
 st40:
 	if ( ++p == pe )
@@ -1425,18 +1690,18 @@ case 42:
 	} else
 		goto st40;
 	goto st0;
-tr67:
-#line 319 "unicorn_http.rl"
+tr72:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st43;
 st43:
 	if ( ++p == pe )
 		goto _test_eof43;
 case 43:
-#line 1437 "unicorn_http.c"
+#line 1702 "unicorn_http.c"
 	switch( (*p) ) {
 		case 37: goto st41;
-		case 47: goto tr71;
+		case 47: goto tr76;
 		case 58: goto st44;
 		case 60: goto st0;
 		case 64: goto st39;
@@ -1467,7 +1732,7 @@ st44:
 case 44:
 	switch( (*p) ) {
 		case 37: goto st41;
-		case 47: goto tr71;
+		case 47: goto tr76;
 		case 60: goto st0;
 		case 64: goto st39;
 		case 127: goto st0;
@@ -1484,15 +1749,15 @@ case 44:
 	} else
 		goto st0;
 	goto st40;
-tr68:
-#line 319 "unicorn_http.rl"
+tr73:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st45;
 st45:
 	if ( ++p == pe )
 		goto _test_eof45;
 case 45:
-#line 1496 "unicorn_http.c"
+#line 1761 "unicorn_http.c"
 	switch( (*p) ) {
 		case 37: goto st41;
 		case 47: goto st0;
@@ -1554,7 +1819,7 @@ st47:
 case 47:
 	switch( (*p) ) {
 		case 37: goto st41;
-		case 47: goto tr71;
+		case 47: goto tr76;
 		case 58: goto st44;
 		case 60: goto st0;
 		case 64: goto st39;
@@ -1569,17 +1834,17 @@ case 47:
 	} else
 		goto st0;
 	goto st40;
-tr62:
-#line 323 "unicorn_http.rl"
+tr67:
+#line 331 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st48;
 st48:
 	if ( ++p == pe )
 		goto _test_eof48;
 case 48:
-#line 1581 "unicorn_http.c"
+#line 1846 "unicorn_http.c"
 	if ( (*p) == 58 )
-		goto tr61;
+		goto tr66;
 	goto st0;
 st49:
 	if ( ++p == pe )
@@ -2093,14 +2358,14 @@ case 67:
 		goto tr3;
 	goto st0;
 tr2:
-#line 319 "unicorn_http.rl"
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st68;
 st68:
 	if ( ++p == pe )
 		goto _test_eof68;
 case 68:
-#line 2104 "unicorn_http.c"
+#line 2369 "unicorn_http.c"
 	switch( (*p) ) {
 		case 32: goto tr3;
 		case 33: goto st49;
@@ -2160,7 +2425,7 @@ st70:
 		goto _test_eof70;
 case 70:
 	switch( (*p) ) {
-		case 32: goto tr95;
+		case 32: goto tr100;
 		case 33: goto st51;
 		case 124: goto st51;
 		case 126: goto st51;
@@ -2183,39 +2448,40 @@ case 70:
 	} else
 		goto st51;
 	goto st0;
-tr95:
-#line 328 "unicorn_http.rl"
+tr100:
+#line 336 "unicorn_http.rl"
 	{ request_method(hp, PTR_TO(mark), LEN(mark, p)); }
 	goto st71;
 st71:
 	if ( ++p == pe )
 		goto _test_eof71;
 case 71:
-#line 2195 "unicorn_http.c"
+#line 2460 "unicorn_http.c"
 	switch( (*p) ) {
-		case 42: goto tr96;
-		case 47: goto tr97;
-		case 72: goto tr98;
-		case 104: goto tr98;
+		case 42: goto tr101;
+		case 47: goto tr102;
+		case 72: goto tr103;
+		case 104: goto tr103;
 	}
 	goto st0;
-tr96:
-#line 319 "unicorn_http.rl"
+tr101:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st72;
 st72:
 	if ( ++p == pe )
 		goto _test_eof72;
 case 72:
-#line 2211 "unicorn_http.c"
+#line 2476 "unicorn_http.c"
 	switch( (*p) ) {
-		case 13: goto tr99;
+		case 10: goto tr104;
+		case 13: goto tr105;
 		case 32: goto tr8;
-		case 35: goto tr100;
+		case 35: goto tr106;
 	}
 	goto st0;
-tr100:
-#line 333 "unicorn_http.rl"
+tr106:
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -2232,8 +2498,8 @@ tr100:
     }
   }
 	goto st73;
-tr110:
-#line 358 "unicorn_http.rl"
+tr119:
+#line 366 "unicorn_http.rl"
 	{
     VALUE val;
 
@@ -2244,7 +2510,7 @@ tr110:
     if (!STR_CSTR_EQ(val, "*"))
       rb_hash_aset(hp->env, g_path_info, val);
   }
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -2261,15 +2527,15 @@ tr110:
     }
   }
 	goto st73;
-tr116:
-#line 352 "unicorn_http.rl"
+tr126:
+#line 360 "unicorn_http.rl"
 	{MARK(start.query, p); }
-#line 353 "unicorn_http.rl"
+#line 361 "unicorn_http.rl"
 	{
     VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -2286,13 +2552,13 @@ tr116:
     }
   }
 	goto st73;
-tr120:
-#line 353 "unicorn_http.rl"
+tr131:
+#line 361 "unicorn_http.rl"
 	{
     VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 333 "unicorn_http.rl"
+#line 341 "unicorn_http.rl"
 	{
     VALUE str;
 
@@ -2313,29 +2579,31 @@ st73:
 	if ( ++p == pe )
 		goto _test_eof73;
 case 73:
-#line 2317 "unicorn_http.c"
+#line 2583 "unicorn_http.c"
 	switch( (*p) ) {
-		case 13: goto tr102;
-		case 32: goto tr37;
+		case 10: goto tr108;
+		case 13: goto tr109;
+		case 32: goto tr42;
 		case 35: goto st0;
-		case 37: goto tr103;
+		case 37: goto tr110;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto tr101;
-tr101:
-#line 319 "unicorn_http.rl"
+	goto tr107;
+tr107:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st74;
 st74:
 	if ( ++p == pe )
 		goto _test_eof74;
 case 74:
-#line 2336 "unicorn_http.c"
+#line 2603 "unicorn_http.c"
 	switch( (*p) ) {
-		case 13: goto tr105;
-		case 32: goto tr40;
+		case 10: goto tr112;
+		case 13: goto tr113;
+		case 32: goto tr45;
 		case 35: goto st0;
 		case 37: goto st75;
 		case 127: goto st0;
@@ -2343,15 +2611,15 @@ case 74:
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
 	goto st74;
-tr103:
-#line 319 "unicorn_http.rl"
+tr110:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st75;
 st75:
 	if ( ++p == pe )
 		goto _test_eof75;
 case 75:
-#line 2355 "unicorn_http.c"
+#line 2623 "unicorn_http.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto st76;
@@ -2374,27 +2642,28 @@ case 76:
 	} else
 		goto st74;
 	goto st0;
-tr97:
-#line 319 "unicorn_http.rl"
+tr102:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st77;
-tr136:
-#line 332 "unicorn_http.rl"
+tr147:
+#line 340 "unicorn_http.rl"
 	{ rb_hash_aset(hp->env, g_http_host, STR_NEW(mark, p)); }
-#line 319 "unicorn_http.rl"
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st77;
 st77:
 	if ( ++p == pe )
 		goto _test_eof77;
 case 77:
-#line 2392 "unicorn_http.c"
+#line 2660 "unicorn_http.c"
 	switch( (*p) ) {
-		case 13: goto tr109;
-		case 32: goto tr44;
-		case 35: goto tr110;
+		case 10: goto tr117;
+		case 13: goto tr118;
+		case 32: goto tr49;
+		case 35: goto tr119;
 		case 37: goto st78;
-		case 63: goto tr112;
+		case 63: goto tr121;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
@@ -2426,8 +2695,8 @@ case 79:
 	} else
 		goto st77;
 	goto st0;
-tr112:
-#line 358 "unicorn_http.rl"
+tr121:
+#line 366 "unicorn_http.rl"
 	{
     VALUE val;
 
@@ -2443,45 +2712,47 @@ st80:
 	if ( ++p == pe )
 		goto _test_eof80;
 case 80:
-#line 2447 "unicorn_http.c"
+#line 2716 "unicorn_http.c"
 	switch( (*p) ) {
-		case 13: goto tr115;
-		case 32: goto tr50;
-		case 35: goto tr116;
-		case 37: goto tr117;
+		case 10: goto tr124;
+		case 13: goto tr125;
+		case 32: goto tr55;
+		case 35: goto tr126;
+		case 37: goto tr127;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto tr114;
-tr114:
-#line 352 "unicorn_http.rl"
+	goto tr123;
+tr123:
+#line 360 "unicorn_http.rl"
 	{MARK(start.query, p); }
 	goto st81;
 st81:
 	if ( ++p == pe )
 		goto _test_eof81;
 case 81:
-#line 2466 "unicorn_http.c"
+#line 2736 "unicorn_http.c"
 	switch( (*p) ) {
-		case 13: goto tr119;
-		case 32: goto tr54;
-		case 35: goto tr120;
+		case 10: goto tr129;
+		case 13: goto tr130;
+		case 32: goto tr59;
+		case 35: goto tr131;
 		case 37: goto st82;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
 	goto st81;
-tr117:
-#line 352 "unicorn_http.rl"
+tr127:
+#line 360 "unicorn_http.rl"
 	{MARK(start.query, p); }
 	goto st82;
 st82:
 	if ( ++p == pe )
 		goto _test_eof82;
 case 82:
-#line 2485 "unicorn_http.c"
+#line 2756 "unicorn_http.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto st83;
@@ -2504,67 +2775,67 @@ case 83:
 	} else
 		goto st81;
 	goto st0;
-tr98:
-#line 319 "unicorn_http.rl"
+tr103:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
-#line 323 "unicorn_http.rl"
+#line 331 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st84;
 st84:
 	if ( ++p == pe )
 		goto _test_eof84;
 case 84:
-#line 2518 "unicorn_http.c"
+#line 2789 "unicorn_http.c"
 	switch( (*p) ) {
-		case 84: goto tr123;
-		case 116: goto tr123;
+		case 84: goto tr134;
+		case 116: goto tr134;
 	}
 	goto st0;
-tr123:
-#line 323 "unicorn_http.rl"
+tr134:
+#line 331 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st85;
 st85:
 	if ( ++p == pe )
 		goto _test_eof85;
 case 85:
-#line 2532 "unicorn_http.c"
+#line 2803 "unicorn_http.c"
 	switch( (*p) ) {
-		case 84: goto tr124;
-		case 116: goto tr124;
+		case 84: goto tr135;
+		case 116: goto tr135;
 	}
 	goto st0;
-tr124:
-#line 323 "unicorn_http.rl"
+tr135:
+#line 331 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st86;
 st86:
 	if ( ++p == pe )
 		goto _test_eof86;
 case 86:
-#line 2546 "unicorn_http.c"
+#line 2817 "unicorn_http.c"
 	switch( (*p) ) {
-		case 80: goto tr125;
-		case 112: goto tr125;
+		case 80: goto tr136;
+		case 112: goto tr136;
 	}
 	goto st0;
-tr125:
-#line 323 "unicorn_http.rl"
+tr136:
+#line 331 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st87;
 st87:
 	if ( ++p == pe )
 		goto _test_eof87;
 case 87:
-#line 2560 "unicorn_http.c"
+#line 2831 "unicorn_http.c"
 	switch( (*p) ) {
-		case 58: goto tr126;
-		case 83: goto tr127;
-		case 115: goto tr127;
+		case 58: goto tr137;
+		case 83: goto tr138;
+		case 115: goto tr138;
 	}
 	goto st0;
-tr126:
-#line 329 "unicorn_http.rl"
+tr137:
+#line 337 "unicorn_http.rl"
 	{
     rb_hash_aset(hp->env, g_rack_url_scheme, STR_NEW(mark, p));
   }
@@ -2573,7 +2844,7 @@ st88:
 	if ( ++p == pe )
 		goto _test_eof88;
 case 88:
-#line 2577 "unicorn_http.c"
+#line 2848 "unicorn_http.c"
 	if ( (*p) == 47 )
 		goto st89;
 	goto st0;
@@ -2592,8 +2863,8 @@ case 90:
 		case 37: goto st92;
 		case 47: goto st0;
 		case 60: goto st0;
-		case 91: goto tr133;
-		case 95: goto tr132;
+		case 91: goto tr144;
+		case 95: goto tr143;
 		case 127: goto st0;
 	}
 	if ( (*p) < 45 ) {
@@ -2608,11 +2879,11 @@ case 90:
 				goto st0;
 		} else if ( (*p) > 90 ) {
 			if ( 97 <= (*p) && (*p) <= 122 )
-				goto tr132;
+				goto tr143;
 		} else
-			goto tr132;
+			goto tr143;
 	} else
-		goto tr132;
+		goto tr143;
 	goto st91;
 st91:
 	if ( ++p == pe )
@@ -2660,18 +2931,18 @@ case 93:
 	} else
 		goto st91;
 	goto st0;
-tr132:
-#line 319 "unicorn_http.rl"
+tr143:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st94;
 st94:
 	if ( ++p == pe )
 		goto _test_eof94;
 case 94:
-#line 2672 "unicorn_http.c"
+#line 2943 "unicorn_http.c"
 	switch( (*p) ) {
 		case 37: goto st92;
-		case 47: goto tr136;
+		case 47: goto tr147;
 		case 58: goto st95;
 		case 60: goto st0;
 		case 64: goto st90;
@@ -2702,7 +2973,7 @@ st95:
 case 95:
 	switch( (*p) ) {
 		case 37: goto st92;
-		case 47: goto tr136;
+		case 47: goto tr147;
 		case 60: goto st0;
 		case 64: goto st90;
 		case 127: goto st0;
@@ -2719,15 +2990,15 @@ case 95:
 	} else
 		goto st0;
 	goto st91;
-tr133:
-#line 319 "unicorn_http.rl"
+tr144:
+#line 327 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st96;
 st96:
 	if ( ++p == pe )
 		goto _test_eof96;
 case 96:
-#line 2731 "unicorn_http.c"
+#line 3002 "unicorn_http.c"
 	switch( (*p) ) {
 		case 37: goto st92;
 		case 47: goto st0;
@@ -2789,7 +3060,7 @@ st98:
 case 98:
 	switch( (*p) ) {
 		case 37: goto st92;
-		case 47: goto tr136;
+		case 47: goto tr147;
 		case 58: goto st95;
 		case 60: goto st0;
 		case 64: goto st90;
@@ -2804,35 +3075,35 @@ case 98:
 	} else
 		goto st0;
 	goto st91;
-tr127:
-#line 323 "unicorn_http.rl"
+tr138:
+#line 331 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st99;
 st99:
 	if ( ++p == pe )
 		goto _test_eof99;
 case 99:
-#line 2816 "unicorn_http.c"
+#line 3087 "unicorn_http.c"
 	if ( (*p) == 58 )
-		goto tr126;
+		goto tr137;
 	goto st0;
 st100:
 	if ( ++p == pe )
 		goto _test_eof100;
 case 100:
 	if ( (*p) == 48 )
-		goto tr140;
+		goto tr151;
 	if ( (*p) < 65 ) {
 		if ( 49 <= (*p) && (*p) <= 57 )
-			goto tr141;
+			goto tr152;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto tr141;
+			goto tr152;
 	} else
-		goto tr141;
+		goto tr152;
 	goto st0;
-tr140:
-#line 368 "unicorn_http.rl"
+tr151:
+#line 376 "unicorn_http.rl"
 	{
     hp->len.chunk = step_incr(hp->len.chunk, (*p), 16);
     if (hp->len.chunk < 0)
@@ -2843,30 +3114,24 @@ st101:
 	if ( ++p == pe )
 		goto _test_eof101;
 case 101:
-#line 2847 "unicorn_http.c"
+#line 3118 "unicorn_http.c"
 	switch( (*p) ) {
+		case 10: goto tr153;
 		case 13: goto st102;
-		case 48: goto tr140;
+		case 48: goto tr151;
 		case 59: goto st111;
 	}
 	if ( (*p) < 65 ) {
 		if ( 49 <= (*p) && (*p) <= 57 )
-			goto tr141;
+			goto tr152;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto tr141;
+			goto tr152;
 	} else
-		goto tr141;
-	goto st0;
-st102:
-	if ( ++p == pe )
-		goto _test_eof102;
-case 102:
-	if ( (*p) == 10 )
-		goto tr144;
+		goto tr152;
 	goto st0;
-tr144:
-#line 397 "unicorn_http.rl"
+tr153:
+#line 405 "unicorn_http.rl"
 	{
     HP_FL_SET(hp, INTRAILER);
     cs = http_parser_en_Trailers;
@@ -2879,10 +3144,17 @@ st123:
 	if ( ++p == pe )
 		goto _test_eof123;
 case 123:
-#line 2883 "unicorn_http.c"
+#line 3148 "unicorn_http.c"
+	goto st0;
+st102:
+	if ( ++p == pe )
+		goto _test_eof102;
+case 102:
+	if ( (*p) == 10 )
+		goto tr153;
 	goto st0;
-tr141:
-#line 368 "unicorn_http.rl"
+tr152:
+#line 376 "unicorn_http.rl"
 	{
     hp->len.chunk = step_incr(hp->len.chunk, (*p), 16);
     if (hp->len.chunk < 0)
@@ -2893,34 +3165,28 @@ st103:
 	if ( ++p == pe )
 		goto _test_eof103;
 case 103:
-#line 2897 "unicorn_http.c"
+#line 3169 "unicorn_http.c"
 	switch( (*p) ) {
-		case 13: goto st104;
+		case 10: goto st104;
+		case 13: goto st107;
 		case 59: goto st108;
 	}
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
-			goto tr141;
+			goto tr152;
 	} else if ( (*p) > 70 ) {
 		if ( 97 <= (*p) && (*p) <= 102 )
-			goto tr141;
+			goto tr152;
 	} else
-		goto tr141;
+		goto tr152;
 	goto st0;
 st104:
 	if ( ++p == pe )
 		goto _test_eof104;
 case 104:
-	if ( (*p) == 10 )
-		goto st105;
-	goto st0;
-st105:
-	if ( ++p == pe )
-		goto _test_eof105;
-case 105:
-	goto tr148;
-tr148:
-#line 405 "unicorn_http.rl"
+	goto tr159;
+tr159:
+#line 413 "unicorn_http.rl"
 	{
   skip_chunk_data_hack: {
     size_t nr = MIN((size_t)hp->len.chunk, REMAINING);
@@ -2934,31 +3200,41 @@ tr148:
       goto post_exec;
     } else {
       p--;
-      {goto st106;}
+      {goto st105;}
     }
   }}
-	goto st106;
+	goto st105;
+st105:
+	if ( ++p == pe )
+		goto _test_eof105;
+case 105:
+#line 3212 "unicorn_http.c"
+	switch( (*p) ) {
+		case 10: goto st100;
+		case 13: goto st106;
+	}
+	goto st0;
 st106:
 	if ( ++p == pe )
 		goto _test_eof106;
 case 106:
-#line 2946 "unicorn_http.c"
-	if ( (*p) == 13 )
-		goto st107;
+	if ( (*p) == 10 )
+		goto st100;
 	goto st0;
 st107:
 	if ( ++p == pe )
 		goto _test_eof107;
 case 107:
 	if ( (*p) == 10 )
-		goto st100;
+		goto st104;
 	goto st0;
 st108:
 	if ( ++p == pe )
 		goto _test_eof108;
 case 108:
 	switch( (*p) ) {
-		case 13: goto st104;
+		case 10: goto st104;
+		case 13: goto st107;
 		case 32: goto st108;
 		case 33: goto st109;
 		case 59: goto st108;
@@ -2989,7 +3265,8 @@ st109:
 		goto _test_eof109;
 case 109:
 	switch( (*p) ) {
-		case 13: goto st104;
+		case 10: goto st104;
+		case 13: goto st107;
 		case 33: goto st109;
 		case 59: goto st108;
 		case 61: goto st110;
@@ -3019,7 +3296,8 @@ st110:
 		goto _test_eof110;
 case 110:
 	switch( (*p) ) {
-		case 13: goto st104;
+		case 10: goto st104;
+		case 13: goto st107;
 		case 33: goto st110;
 		case 59: goto st108;
 		case 124: goto st110;
@@ -3048,6 +3326,7 @@ st111:
 		goto _test_eof111;
 case 111:
 	switch( (*p) ) {
+		case 10: goto tr153;
 		case 13: goto st102;
 		case 32: goto st111;
 		case 33: goto st112;
@@ -3079,6 +3358,7 @@ st112:
 		goto _test_eof112;
 case 112:
 	switch( (*p) ) {
+		case 10: goto tr153;
 		case 13: goto st102;
 		case 33: goto st112;
 		case 59: goto st111;
@@ -3109,6 +3389,7 @@ st113:
 		goto _test_eof113;
 case 113:
 	switch( (*p) ) {
+		case 10: goto tr153;
 		case 13: goto st102;
 		case 33: goto st113;
 		case 59: goto st111;
@@ -3133,110 +3414,127 @@ case 113:
 	} else
 		goto st113;
 	goto st0;
+tr172:
+#line 333 "unicorn_http.rl"
+	{ MARK(mark, p); }
+#line 335 "unicorn_http.rl"
+	{ write_cont_value(hp, buffer, p); }
+	goto st114;
+tr175:
+#line 335 "unicorn_http.rl"
+	{ write_cont_value(hp, buffer, p); }
+	goto st114;
+tr182:
+#line 333 "unicorn_http.rl"
+	{ MARK(mark, p); }
+#line 334 "unicorn_http.rl"
+	{ write_value(hp, buffer, p); }
+	goto st114;
+tr185:
+#line 334 "unicorn_http.rl"
+	{ write_value(hp, buffer, p); }
+	goto st114;
 st114:
 	if ( ++p == pe )
 		goto _test_eof114;
 case 114:
+#line 3442 "unicorn_http.c"
 	switch( (*p) ) {
 		case 9: goto st115;
+		case 10: goto tr167;
 		case 13: goto st118;
 		case 32: goto st115;
-		case 33: goto tr157;
-		case 124: goto tr157;
-		case 126: goto tr157;
+		case 33: goto tr169;
+		case 124: goto tr169;
+		case 126: goto tr169;
 	}
 	if ( (*p) < 45 ) {
 		if ( (*p) > 39 ) {
 			if ( 42 <= (*p) && (*p) <= 43 )
-				goto tr157;
+				goto tr169;
 		} else if ( (*p) >= 35 )
-			goto tr157;
+			goto tr169;
 	} else if ( (*p) > 46 ) {
 		if ( (*p) < 65 ) {
 			if ( 48 <= (*p) && (*p) <= 57 )
-				goto tr157;
+				goto tr169;
 		} else if ( (*p) > 90 ) {
 			if ( 94 <= (*p) && (*p) <= 122 )
-				goto tr157;
+				goto tr169;
 		} else
-			goto tr157;
+			goto tr169;
 	} else
-		goto tr157;
+		goto tr169;
 	goto st0;
-tr159:
-#line 325 "unicorn_http.rl"
+tr171:
+#line 333 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st115;
 st115:
 	if ( ++p == pe )
 		goto _test_eof115;
 case 115:
-#line 3175 "unicorn_http.c"
+#line 3478 "unicorn_http.c"
 	switch( (*p) ) {
-		case 9: goto tr159;
-		case 13: goto tr160;
-		case 32: goto tr159;
+		case 9: goto tr171;
+		case 10: goto tr172;
+		case 13: goto tr173;
+		case 32: goto tr171;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto tr158;
-tr158:
-#line 325 "unicorn_http.rl"
+	goto tr170;
+tr170:
+#line 333 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st116;
 st116:
 	if ( ++p == pe )
 		goto _test_eof116;
 case 116:
-#line 3193 "unicorn_http.c"
+#line 3497 "unicorn_http.c"
 	switch( (*p) ) {
-		case 13: goto tr162;
+		case 10: goto tr175;
+		case 13: goto tr176;
 		case 127: goto st0;
 	}
 	if ( (*p) > 8 ) {
-		if ( 10 <= (*p) && (*p) <= 31 )
+		if ( 11 <= (*p) && (*p) <= 31 )
 			goto st0;
 	} else if ( (*p) >= 0 )
 		goto st0;
 	goto st116;
-tr160:
-#line 325 "unicorn_http.rl"
+tr173:
+#line 333 "unicorn_http.rl"
 	{ MARK(mark, p); }
-#line 327 "unicorn_http.rl"
+#line 335 "unicorn_http.rl"
 	{ write_cont_value(hp, buffer, p); }
 	goto st117;
-tr162:
-#line 327 "unicorn_http.rl"
+tr176:
+#line 335 "unicorn_http.rl"
 	{ write_cont_value(hp, buffer, p); }
 	goto st117;
-tr169:
-#line 325 "unicorn_http.rl"
+tr183:
+#line 333 "unicorn_http.rl"
 	{ MARK(mark, p); }
-#line 326 "unicorn_http.rl"
+#line 334 "unicorn_http.rl"
 	{ write_value(hp, buffer, p); }
 	goto st117;
-tr171:
-#line 326 "unicorn_http.rl"
+tr186:
+#line 334 "unicorn_http.rl"
 	{ write_value(hp, buffer, p); }
 	goto st117;
 st117:
 	if ( ++p == pe )
 		goto _test_eof117;
 case 117:
-#line 3228 "unicorn_http.c"
+#line 3533 "unicorn_http.c"
 	if ( (*p) == 10 )
 		goto st114;
 	goto st0;
-st118:
-	if ( ++p == pe )
-		goto _test_eof118;
-case 118:
-	if ( (*p) == 10 )
-		goto tr164;
-	goto st0;
-tr164:
-#line 392 "unicorn_http.rl"
+tr167:
+#line 400 "unicorn_http.rl"
 	{
     cs = http_parser_first_final;
     goto post_exec;
@@ -3246,84 +3544,93 @@ st124:
 	if ( ++p == pe )
 		goto _test_eof124;
 case 124:
-#line 3250 "unicorn_http.c"
+#line 3548 "unicorn_http.c"
+	goto st0;
+st118:
+	if ( ++p == pe )
+		goto _test_eof118;
+case 118:
+	if ( (*p) == 10 )
+		goto tr167;
 	goto st0;
-tr157:
-#line 321 "unicorn_http.rl"
+tr169:
+#line 329 "unicorn_http.rl"
 	{ MARK(start.field, p); }
-#line 322 "unicorn_http.rl"
+#line 330 "unicorn_http.rl"
 	{ snake_upcase_char(deconst(p)); }
 	goto st119;
-tr165:
-#line 322 "unicorn_http.rl"
+tr178:
+#line 330 "unicorn_http.rl"
 	{ snake_upcase_char(deconst(p)); }
 	goto st119;
 st119:
 	if ( ++p == pe )
 		goto _test_eof119;
 case 119:
-#line 3266 "unicorn_http.c"
+#line 3571 "unicorn_http.c"
 	switch( (*p) ) {
-		case 33: goto tr165;
-		case 58: goto tr166;
-		case 124: goto tr165;
-		case 126: goto tr165;
+		case 33: goto tr178;
+		case 58: goto tr179;
+		case 124: goto tr178;
+		case 126: goto tr178;
 	}
 	if ( (*p) < 45 ) {
 		if ( (*p) > 39 ) {
 			if ( 42 <= (*p) && (*p) <= 43 )
-				goto tr165;
+				goto tr178;
 		} else if ( (*p) >= 35 )
-			goto tr165;
+			goto tr178;
 	} else if ( (*p) > 46 ) {
 		if ( (*p) < 65 ) {
 			if ( 48 <= (*p) && (*p) <= 57 )
-				goto tr165;
+				goto tr178;
 		} else if ( (*p) > 90 ) {
 			if ( 94 <= (*p) && (*p) <= 122 )
-				goto tr165;
+				goto tr178;
 		} else
-			goto tr165;
+			goto tr178;
 	} else
-		goto tr165;
+		goto tr178;
 	goto st0;
-tr168:
-#line 325 "unicorn_http.rl"
+tr181:
+#line 333 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st120;
-tr166:
-#line 324 "unicorn_http.rl"
+tr179:
+#line 332 "unicorn_http.rl"
 	{ hp->s.field_len = LEN(start.field, p); }
 	goto st120;
 st120:
 	if ( ++p == pe )
 		goto _test_eof120;
 case 120:
-#line 3303 "unicorn_http.c"
+#line 3608 "unicorn_http.c"
 	switch( (*p) ) {
-		case 9: goto tr168;
-		case 13: goto tr169;
-		case 32: goto tr168;
+		case 9: goto tr181;
+		case 10: goto tr182;
+		case 13: goto tr183;
+		case 32: goto tr181;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto tr167;
-tr167:
-#line 325 "unicorn_http.rl"
+	goto tr180;
+tr180:
+#line 333 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st121;
 st121:
 	if ( ++p == pe )
 		goto _test_eof121;
 case 121:
-#line 3321 "unicorn_http.c"
+#line 3627 "unicorn_http.c"
 	switch( (*p) ) {
-		case 13: goto tr171;
+		case 10: goto tr185;
+		case 13: goto tr186;
 		case 127: goto st0;
 	}
 	if ( (*p) > 8 ) {
-		if ( 10 <= (*p) && (*p) <= 31 )
+		if ( 11 <= (*p) && (*p) <= 31 )
 			goto st0;
 	} else if ( (*p) >= 0 )
 		goto st0;
@@ -3345,8 +3652,8 @@ case 121:
 	_test_eof15: cs = 15; goto _test_eof; 
 	_test_eof16: cs = 16; goto _test_eof; 
 	_test_eof17: cs = 17; goto _test_eof; 
-	_test_eof18: cs = 18; goto _test_eof; 
 	_test_eof122: cs = 122; goto _test_eof; 
+	_test_eof18: cs = 18; goto _test_eof; 
 	_test_eof19: cs = 19; goto _test_eof; 
 	_test_eof20: cs = 20; goto _test_eof; 
 	_test_eof21: cs = 21; goto _test_eof; 
@@ -3430,8 +3737,8 @@ case 121:
 	_test_eof99: cs = 99; goto _test_eof; 
 	_test_eof100: cs = 100; goto _test_eof; 
 	_test_eof101: cs = 101; goto _test_eof; 
-	_test_eof102: cs = 102; goto _test_eof; 
 	_test_eof123: cs = 123; goto _test_eof; 
+	_test_eof102: cs = 102; goto _test_eof; 
 	_test_eof103: cs = 103; goto _test_eof; 
 	_test_eof104: cs = 104; goto _test_eof; 
 	_test_eof105: cs = 105; goto _test_eof; 
@@ -3447,8 +3754,8 @@ case 121:
 	_test_eof115: cs = 115; goto _test_eof; 
 	_test_eof116: cs = 116; goto _test_eof; 
 	_test_eof117: cs = 117; goto _test_eof; 
-	_test_eof118: cs = 118; goto _test_eof; 
 	_test_eof124: cs = 124; goto _test_eof; 
+	_test_eof118: cs = 118; goto _test_eof; 
 	_test_eof119: cs = 119; goto _test_eof; 
 	_test_eof120: cs = 120; goto _test_eof; 
 	_test_eof121: cs = 121; goto _test_eof; 
@@ -3457,21 +3764,41 @@ case 121:
 	_out: {}
 	}
 
-#line 466 "unicorn_http.rl"
+#line 474 "unicorn_http.rl"
 post_exec: /* "_out:" also goes here */
   if (hp->cs != http_parser_error)
     hp->cs = cs;
-  hp->offset = p - buffer;
+  hp->offset = ulong2uint(p - buffer);
 
   assert(p <= pe && "buffer overflow after parsing execute");
   assert(hp->offset <= len && "offset longer than length");
 }
 
+static void hp_mark(void *ptr)
+{
+  struct http_parser *hp = ptr;
+
+  rb_gc_mark(hp->buf);
+  rb_gc_mark(hp->env);
+  rb_gc_mark(hp->cont);
+}
+
+static size_t hp_memsize(const void *ptr)
+{
+  return sizeof(struct http_parser);
+}
+
+static const rb_data_type_t hp_type = {
+  "unicorn_http",
+  { hp_mark, RUBY_TYPED_DEFAULT_FREE, hp_memsize, /* reserved */ },
+  /* parent, data, [ flags ] */
+};
+
 static struct http_parser *data_get(VALUE self)
 {
   struct http_parser *hp;
 
-  Data_Get_Struct(self, struct http_parser, hp);
+  TypedData_Get_Struct(self, struct http_parser, &hp_type, hp);
   assert(hp && "failed to extract http_parser struct");
   return hp;
 }
@@ -3486,26 +3813,29 @@ static void set_url_scheme(VALUE env, VALUE *server_port)
   VALUE scheme = rb_hash_aref(env, g_rack_url_scheme);
 
   if (NIL_P(scheme)) {
-    if (trust_x_forward == Qfalse) {
-      scheme = g_http;
+    /*
+     * would anybody be horribly opposed to removing the X-Forwarded-SSL
+     * and X-Forwarded-Proto handling from this parser?  We've had it
+     * forever and nobody has said anything against it, either.
+     * Anyways, please send comments to our public mailing list:
+     * unicorn-public@yhbt.net (no HTML mail, no subscription necessary)
+     */
+    scheme = rb_hash_aref(env, g_http_x_forwarded_ssl);
+    if (!NIL_P(scheme) && STR_CSTR_EQ(scheme, "on")) {
+      *server_port = g_port_443;
+      scheme = g_https;
     } else {
-      scheme = rb_hash_aref(env, g_http_x_forwarded_ssl);
-      if (!NIL_P(scheme) && STR_CSTR_EQ(scheme, "on")) {
-        *server_port = g_port_443;
-        scheme = g_https;
+      scheme = rb_hash_aref(env, g_http_x_forwarded_proto);
+      if (NIL_P(scheme)) {
+        scheme = g_http;
       } else {
-        scheme = rb_hash_aref(env, g_http_x_forwarded_proto);
-        if (NIL_P(scheme)) {
-          scheme = g_http;
+        long len = RSTRING_LEN(scheme);
+        if (len >= 5 && !memcmp(RSTRING_PTR(scheme), "https", 5)) {
+          if (len != 5)
+            scheme = g_https;
+          *server_port = g_port_443;
         } else {
-          long len = RSTRING_LEN(scheme);
-          if (len >= 5 && !memcmp(RSTRING_PTR(scheme), "https", 5)) {
-            if (len != 5)
-              scheme = g_https;
-            *server_port = g_port_443;
-          } else {
-            scheme = g_http;
-          }
+          scheme = g_http;
         }
       }
     }
@@ -3574,21 +3904,12 @@ static void finalize_header(struct http_parser *hp)
     rb_hash_aset(hp->env, g_query_string, rb_str_new(NULL, 0));
 }
 
-static void hp_mark(void *ptr)
-{
-  struct http_parser *hp = ptr;
-
-  rb_gc_mark(hp->buf);
-  rb_gc_mark(hp->env);
-  rb_gc_mark(hp->cont);
-}
-
 static VALUE HttpParser_alloc(VALUE klass)
 {
   struct http_parser *hp;
-  return Data_Make_Struct(klass, struct http_parser, hp_mark, -1, hp);
-}
 
+  return TypedData_Make_Struct(klass, struct http_parser, &hp_type, hp);
+}
 
 /**
  * call-seq:
@@ -3603,7 +3924,6 @@ static VALUE HttpParser_init(VALUE self)
   http_parser_init(hp);
   hp->buf = rb_str_new(NULL, 0);
   hp->env = rb_hash_new();
-  hp->nr_requests = keepalive_requests;
 
   return self;
 }
@@ -3619,62 +3939,16 @@ static VALUE HttpParser_clear(VALUE self)
 {
   struct http_parser *hp = data_get(self);
 
-  http_parser_init(hp);
-  rb_funcall(hp->env, id_clear, 0);
-  rb_ivar_set(self, id_response_start_sent, Qfalse);
-
-  return self;
-}
-
-/**
- * call-seq:
- *    parser.dechunk! => parser
- *
- * Resets the parser to a state suitable for dechunking response bodies
- *
- */
-static VALUE HttpParser_dechunk_bang(VALUE self)
-{
-  struct http_parser *hp = data_get(self);
+  /* we can't safely reuse .buf and .env if hijacked */
+  if (HP_FL_TEST(hp, HIJACK))
+    return HttpParser_init(self);
 
   http_parser_init(hp);
-
-  /*
-   * we don't care about trailers in dechunk-only mode,
-   * but if we did we'd set UH_FL_HASTRAILER and clear hp->env
-   */
-  if (0) {
-    rb_funcall(hp->env, id_clear, 0);
-    hp->flags = UH_FL_HASTRAILER;
-  }
-
-  hp->flags |= UH_FL_HASBODY | UH_FL_INBODY | UH_FL_CHUNKED;
-  hp->cs = http_parser_en_ChunkedBody;
+  my_hash_clear(hp->env);
 
   return self;
 }
 
-/**
- * call-seq:
- *    parser.reset => nil
- *
- * Resets the parser to it's initial state so that you can reuse it
- * rather than making new ones.
- *
- * This method is deprecated and to be removed in Unicorn 4.x
- */
-static VALUE HttpParser_reset(VALUE self)
-{
-  static int warned;
-
-  if (!warned) {
-    rb_warn("Unicorn::HttpParser#reset is deprecated; "
-            "use Unicorn::HttpParser#clear instead");
-  }
-  HttpParser_clear(self);
-  return Qnil;
-}
-
 static void advance_str(VALUE str, off_t nr)
 {
   long len = RSTRING_LEN(str);
@@ -3837,15 +4111,13 @@ static VALUE HttpParser_keepalive(VALUE self)
  *    parser.next? => true or false
  *
  * Exactly like HttpParser#keepalive?, except it will reset the internal
- * parser state on next parse if it returns true.  It will also respect
- * the maximum *keepalive_requests* value and return false if that is
- * reached.
+ * parser state on next parse if it returns true.
  */
 static VALUE HttpParser_next(VALUE self)
 {
   struct http_parser *hp = data_get(self);
 
-  if ((HP_FL_ALL(hp, KEEPALIVE)) && (hp->nr_requests-- != 0)) {
+  if (HP_FL_ALL(hp, KEEPALIVE)) {
     HP_FL_SET(hp, TO_CLEAR);
     return Qtrue;
   }
@@ -3877,6 +4149,15 @@ static VALUE HttpParser_env(VALUE self)
   return data_get(self)->env;
 }
 
+static VALUE HttpParser_hijacked_bang(VALUE self)
+{
+  struct http_parser *hp = data_get(self);
+
+  HP_FL_SET(hp, HIJACK);
+
+  return self;
+}
+
 /**
  * call-seq:
  *    parser.filter_body(dst, src) => nil/src
@@ -3955,6 +4236,25 @@ static VALUE HttpParser_filter_body(VALUE self, VALUE dst, VALUE src)
   return src;
 }
 
+static VALUE HttpParser_rssset(VALUE self, VALUE boolean)
+{
+  struct http_parser *hp = data_get(self);
+
+  if (RTEST(boolean))
+    HP_FL_SET(hp, RESSTART);
+  else
+    HP_FL_UNSET(hp, RESSTART);
+
+  return boolean; /* ignored by Ruby anyways */
+}
+
+static VALUE HttpParser_rssget(VALUE self)
+{
+  struct http_parser *hp = data_get(self);
+
+  return HP_FL_TEST(hp, RESSTART) ? Qtrue : Qfalse;
+}
+
 #define SET_GLOBAL(var,str) do { \
   var = find_common_field(str, sizeof(str) - 1); \
   assert(!NIL_P(var) && "missed global field"); \
@@ -3962,9 +4262,9 @@ static VALUE HttpParser_filter_body(VALUE self, VALUE dst, VALUE src)
 
 void Init_unicorn_http(void)
 {
-  VALUE mUnicorn, cHttpParser;
+  VALUE mUnicorn;
 
-  mUnicorn = rb_const_get(rb_cObject, rb_intern("Unicorn"));
+  mUnicorn = rb_define_module("Unicorn");
   cHttpParser = rb_define_class_under(mUnicorn, "HttpParser", rb_cObject);
   eHttpParserError =
          rb_define_class_under(mUnicorn, "HttpParserError", rb_eIOError);
@@ -3977,8 +4277,6 @@ void Init_unicorn_http(void)
   rb_define_alloc_func(cHttpParser, HttpParser_alloc);
   rb_define_method(cHttpParser, "initialize", HttpParser_init, 0);
   rb_define_method(cHttpParser, "clear", HttpParser_clear, 0);
-  rb_define_method(cHttpParser, "reset", HttpParser_reset, 0);
-  rb_define_method(cHttpParser, "dechunk!", HttpParser_dechunk_bang, 0);
   rb_define_method(cHttpParser, "parse", HttpParser_parse, 0);
   rb_define_method(cHttpParser, "add_parse", HttpParser_add_parse, 1);
   rb_define_method(cHttpParser, "headers", HttpParser_headers, 2);
@@ -3991,6 +4289,9 @@ void Init_unicorn_http(void)
   rb_define_method(cHttpParser, "next?", HttpParser_next, 0);
   rb_define_method(cHttpParser, "buf", HttpParser_buf, 0);
   rb_define_method(cHttpParser, "env", HttpParser_env, 0);
+  rb_define_method(cHttpParser, "hijacked!", HttpParser_hijacked_bang, 0);
+  rb_define_method(cHttpParser, "response_start_sent=", HttpParser_rssset, 1);
+  rb_define_method(cHttpParser, "response_start_sent", HttpParser_rssget, 0);
 
   /*
    * The maximum size a single chunk when using chunked transfer encoding.
@@ -4007,14 +4308,6 @@ void Init_unicorn_http(void)
    */
   rb_define_const(cHttpParser, "LENGTH_MAX", OFFT2NUM(UH_OFF_T_MAX));
 
-  /* default value for keepalive_requests */
-  rb_define_const(cHttpParser, "KEEPALIVE_REQUESTS_DEFAULT",
-                  ULONG2NUM(keepalive_requests));
-
-  rb_define_singleton_method(cHttpParser, "keepalive_requests", ka_req, 0);
-  rb_define_singleton_method(cHttpParser, "keepalive_requests=", set_ka_req, 1);
-  rb_define_singleton_method(cHttpParser, "trust_x_forwarded=", set_xftrust, 1);
-  rb_define_singleton_method(cHttpParser, "trust_x_forwarded?", xftrust, 0);
   rb_define_singleton_method(cHttpParser, "max_header_len=", set_maxhdrlen, 1);
 
   init_common_fields();
@@ -4023,9 +4316,12 @@ void Init_unicorn_http(void)
   SET_GLOBAL(g_http_transfer_encoding, "TRANSFER_ENCODING");
   SET_GLOBAL(g_content_length, "CONTENT_LENGTH");
   SET_GLOBAL(g_http_connection, "CONNECTION");
-  id_clear = rb_intern("clear");
   id_set_backtrace = rb_intern("set_backtrace");
-  id_response_start_sent = rb_intern("@response_start_sent");
   init_unicorn_httpdate();
+
+#ifndef HAVE_RB_HASH_CLEAR
+  id_clear = rb_intern("clear");
+#endif
+  id_is_chunked_p = rb_intern("is_chunked?");
 }
 #undef SET_GLOBAL