unicorn 3.6.0 → 4.0.0

data/ext/unicorn_http/unicorn_http.c

@@ -84,6 +84,14 @@ static VALUE xftrust(VALUE self)
   return trust_x_forward;
 }
 
+static size_t 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));
+}
+
 /* keep this small for Rainbows! since every client has one */
 struct http_parser {
   int cs; /* Ragel internal state */
@@ -108,17 +116,17 @@ struct http_parser {
   } len;
 };
 
-static ID id_clear;
+static ID id_clear, id_set_backtrace;
 
 static void finalize_header(struct http_parser *hp);
 
-static void parser_error(const char *msg)
+static void parser_raise(VALUE klass, const char *msg)
 {
-  VALUE exc = rb_exc_new2(eHttpParserError, msg);
+  VALUE exc = rb_exc_new2(klass, msg);
   VALUE bt = rb_ary_new();
 
-  rb_funcall(exc, rb_intern("set_backtrace"), 1, bt);
-  rb_exc_raise(exc);
+	rb_funcall(exc, id_set_backtrace, 1, bt);
+	rb_exc_raise(exc);
 }
 
 #define REMAINING (unsigned long)(pe - p)
@@ -126,12 +134,27 @@ static void parser_error(const char *msg)
 #define MARK(M,FPC) (hp->M = (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))
 
 #define HP_FL_TEST(hp,fl) ((hp)->flags & (UH_FL_##fl))
 #define HP_FL_SET(hp,fl) ((hp)->flags |= (UH_FL_##fl))
 #define HP_FL_UNSET(hp,fl) ((hp)->flags &= ~(UH_FL_##fl))
 #define HP_FL_ALL(hp,fl) (HP_FL_TEST(hp, fl) == (UH_FL_##fl))
 
+static int is_lws(char c)
+{
+  return (c == ' ' || c == '\t');
+}
+
+static VALUE stripped_str_new(const char *str, long len)
+{
+  long end;
+
+  for (end = len - 1; end >= 0 && is_lws(str[end]); end--);
+
+  return rb_str_new(str, end + 1);
+}
+
 /*
  * handles values of the "Connection:" header, keepalive is implied
  * for HTTP/1.1 but needs to be explicitly enabled with HTTP/1.0
@@ -188,35 +211,43 @@ http_version(struct http_parser *hp, const char *ptr, size_t len)
 static inline void hp_invalid_if_trailer(struct http_parser *hp)
 {
   if (HP_FL_TEST(hp, INTRAILER))
-    parser_error("invalid Trailer");
+    parser_raise(eHttpParserError, "invalid Trailer");
 }
 
 static void write_cont_value(struct http_parser *hp,
                              char *buffer, const char *p)
 {
   char *vptr;
+  long end;
+  long len = LEN(mark, p);
+  long cont_len;
 
   if (hp->cont == Qfalse)
-     parser_error("invalid continuation line");
+     parser_raise(eHttpParserError, "invalid continuation line");
   if (NIL_P(hp->cont))
      return; /* we're ignoring this header (probably Host:) */
 
   assert(TYPE(hp->cont) == T_STRING && "continuation line is not a string");
   assert(hp->mark > 0 && "impossible continuation line offset");
 
-  if (LEN(mark, p) == 0)
+  if (len == 0)
     return;
 
-  if (RSTRING_LEN(hp->cont) > 0)
+  cont_len = RSTRING_LEN(hp->cont);
+  if (cont_len > 0) {
     --hp->mark;
-
+    len = LEN(mark, p);
+  }
   vptr = PTR_TO(mark);
 
-  if (RSTRING_LEN(hp->cont) > 0) {
+  /* normalize tab to space */
+  if (cont_len > 0) {
     assert((' ' == *vptr || '\t' == *vptr) && "invalid leading white space");
     *vptr = ' ';
   }
-  rb_str_buf_cat(hp->cont, vptr, LEN(mark, p));
+
+  for (end = len - 1; end >= 0 && is_lws(vptr[end]); end--);
+  rb_str_buf_cat(hp->cont, vptr, end + 1);
 }
 
 static void write_value(struct http_parser *hp,
@@ -227,7 +258,7 @@ static void write_value(struct http_parser *hp,
   VALUE e;
 
   VALIDATE_MAX_LENGTH(LEN(mark, p), FIELD_VALUE);
-  v = LEN(mark, p) == 0 ? rb_str_buf_new(128) : STR_NEW(mark, p);
+  v = LEN(mark, p) == 0 ? rb_str_buf_new(128) : STRIPPED_STR_NEW(mark, p);
   if (NIL_P(f)) {
     const char *field = PTR_TO(start.field);
     size_t flen = hp->s.field_len;
@@ -248,7 +279,7 @@ static void write_value(struct http_parser *hp,
   } else if (f == g_content_length) {
     hp->len.content = parse_length(RSTRING_PTR(v), RSTRING_LEN(v));
     if (hp->len.content < 0)
-      parser_error("invalid Content-Length");
+      parser_raise(eHttpParserError, "invalid Content-Length");
     if (hp->len.content != 0)
       HP_FL_SET(hp, HASBODY);
     hp_invalid_if_trailer(hp);
@@ -284,12 +315,12 @@ static void write_value(struct http_parser *hp,
 /** Machine **/
 
 
-#line 391 "unicorn_http.rl"
+#line 422 "unicorn_http.rl"
 
 
 /** Data **/
 
-#line 293 "unicorn_http.c"
+#line 324 "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;
@@ -300,7 +331,7 @@ static const int http_parser_en_Trailers = 114;
 static const int http_parser_en_main = 1;
 
 
-#line 395 "unicorn_http.rl"
+#line 426 "unicorn_http.rl"
 
 static void http_parser_init(struct http_parser *hp)
 {
@@ -313,12 +344,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 317 "unicorn_http.c"
+#line 348 "unicorn_http.c"
 	{
 	cs = http_parser_start;
 	}
 
-#line 407 "unicorn_http.rl"
+#line 438 "unicorn_http.rl"
   hp->cs = cs;
 }
 
@@ -346,7 +377,7 @@ http_parser_execute(struct http_parser *hp, char *buffer, size_t len)
     goto skip_chunk_data_hack;
   }
   
-#line 350 "unicorn_http.c"
+#line 381 "unicorn_http.c"
 	{
 	if ( p == pe )
 		goto _test_eof;
@@ -381,14 +412,14 @@ st0:
 cs = 0;
 	goto _out;
 tr0:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st2;
 st2:
 	if ( ++p == pe )
 		goto _test_eof2;
 case 2:
-#line 392 "unicorn_http.c"
+#line 423 "unicorn_http.c"
 	switch( (*p) ) {
 		case 32: goto tr3;
 		case 33: goto st49;
@@ -414,14 +445,14 @@ case 2:
 		goto st49;
 	goto st0;
 tr3:
-#line 296 "unicorn_http.rl"
+#line 327 "unicorn_http.rl"
 	{ request_method(hp, PTR_TO(mark), LEN(mark, p)); }
 	goto st3;
 st3:
 	if ( ++p == pe )
 		goto _test_eof3;
 case 3:
-#line 425 "unicorn_http.c"
+#line 456 "unicorn_http.c"
 	switch( (*p) ) {
 		case 42: goto tr5;
 		case 47: goto tr6;
@@ -430,25 +461,25 @@ case 3:
 	}
 	goto st0;
 tr5:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st4;
 st4:
 	if ( ++p == pe )
 		goto _test_eof4;
 case 4:
-#line 441 "unicorn_http.c"
+#line 472 "unicorn_http.c"
 	switch( (*p) ) {
 		case 32: goto tr8;
 		case 35: goto tr9;
 	}
 	goto st0;
 tr8:
-#line 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -462,38 +493,38 @@ tr8:
   }
 	goto st5;
 tr37:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
-#line 316 "unicorn_http.rl"
+#line 347 "unicorn_http.rl"
 	{
-    VALIDATE_MAX_LENGTH(LEN(mark, p), FRAGMENT);
+    VALIDATE_MAX_URI_LENGTH(LEN(mark, p), FRAGMENT);
     rb_hash_aset(hp->env, g_fragment, STR_NEW(mark, p));
   }
 	goto st5;
 tr40:
-#line 316 "unicorn_http.rl"
+#line 347 "unicorn_http.rl"
 	{
-    VALIDATE_MAX_LENGTH(LEN(mark, p), FRAGMENT);
+    VALIDATE_MAX_URI_LENGTH(LEN(mark, p), FRAGMENT);
     rb_hash_aset(hp->env, g_fragment, STR_NEW(mark, p));
   }
 	goto st5;
 tr44:
-#line 326 "unicorn_http.rl"
+#line 357 "unicorn_http.rl"
 	{
     VALUE val;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_PATH);
+    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 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -507,18 +538,18 @@ tr44:
   }
 	goto st5;
 tr50:
-#line 320 "unicorn_http.rl"
+#line 351 "unicorn_http.rl"
 	{MARK(start.query, p); }
-#line 321 "unicorn_http.rl"
+#line 352 "unicorn_http.rl"
 	{
-    VALIDATE_MAX_LENGTH(LEN(start.query, p), QUERY_STRING);
+    VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -532,16 +563,16 @@ tr50:
   }
 	goto st5;
 tr54:
-#line 321 "unicorn_http.rl"
+#line 352 "unicorn_http.rl"
 	{
-    VALIDATE_MAX_LENGTH(LEN(start.query, p), QUERY_STRING);
+    VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -558,19 +589,19 @@ st5:
 	if ( ++p == pe )
 		goto _test_eof5;
 case 5:
-#line 562 "unicorn_http.c"
+#line 593 "unicorn_http.c"
 	if ( (*p) == 72 )
 		goto tr10;
 	goto st0;
 tr10:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st6;
 st6:
 	if ( ++p == pe )
 		goto _test_eof6;
 case 6:
-#line 574 "unicorn_http.c"
+#line 605 "unicorn_http.c"
 	if ( (*p) == 84 )
 		goto st7;
 	goto st0;
@@ -628,34 +659,34 @@ case 13:
 		goto st13;
 	goto st0;
 tr18:
-#line 325 "unicorn_http.rl"
+#line 356 "unicorn_http.rl"
 	{ http_version(hp, PTR_TO(mark), LEN(mark, p)); }
 	goto st14;
 tr25:
-#line 293 "unicorn_http.rl"
+#line 324 "unicorn_http.rl"
 	{ MARK(mark, p); }
-#line 295 "unicorn_http.rl"
+#line 326 "unicorn_http.rl"
 	{ write_cont_value(hp, buffer, p); }
 	goto st14;
 tr27:
-#line 295 "unicorn_http.rl"
+#line 326 "unicorn_http.rl"
 	{ write_cont_value(hp, buffer, p); }
 	goto st14;
 tr33:
-#line 293 "unicorn_http.rl"
+#line 324 "unicorn_http.rl"
 	{ MARK(mark, p); }
-#line 294 "unicorn_http.rl"
+#line 325 "unicorn_http.rl"
 	{ write_value(hp, buffer, p); }
 	goto st14;
 tr35:
-#line 294 "unicorn_http.rl"
+#line 325 "unicorn_http.rl"
 	{ write_value(hp, buffer, p); }
 	goto st14;
 st14:
 	if ( ++p == pe )
 		goto _test_eof14;
 case 14:
-#line 659 "unicorn_http.c"
+#line 690 "unicorn_http.c"
 	if ( (*p) == 10 )
 		goto st15;
 	goto st0;
@@ -690,14 +721,14 @@ case 15:
 		goto tr22;
 	goto st0;
 tr24:
-#line 293 "unicorn_http.rl"
+#line 324 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st16;
 st16:
 	if ( ++p == pe )
 		goto _test_eof16;
 case 16:
-#line 701 "unicorn_http.c"
+#line 732 "unicorn_http.c"
 	switch( (*p) ) {
 		case 9: goto tr24;
 		case 13: goto tr25;
@@ -705,23 +736,23 @@ case 16:
 	}
 	goto tr23;
 tr23:
-#line 293 "unicorn_http.rl"
+#line 324 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st17;
 st17:
 	if ( ++p == pe )
 		goto _test_eof17;
 case 17:
-#line 716 "unicorn_http.c"
+#line 747 "unicorn_http.c"
 	if ( (*p) == 13 )
 		goto tr27;
 	goto st17;
 tr99:
-#line 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -735,38 +766,38 @@ tr99:
   }
 	goto st18;
 tr102:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
-#line 316 "unicorn_http.rl"
+#line 347 "unicorn_http.rl"
 	{
-    VALIDATE_MAX_LENGTH(LEN(mark, p), FRAGMENT);
+    VALIDATE_MAX_URI_LENGTH(LEN(mark, p), FRAGMENT);
     rb_hash_aset(hp->env, g_fragment, STR_NEW(mark, p));
   }
 	goto st18;
 tr105:
-#line 316 "unicorn_http.rl"
+#line 347 "unicorn_http.rl"
 	{
-    VALIDATE_MAX_LENGTH(LEN(mark, p), FRAGMENT);
+    VALIDATE_MAX_URI_LENGTH(LEN(mark, p), FRAGMENT);
     rb_hash_aset(hp->env, g_fragment, STR_NEW(mark, p));
   }
 	goto st18;
 tr109:
-#line 326 "unicorn_http.rl"
+#line 357 "unicorn_http.rl"
 	{
     VALUE val;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_PATH);
+    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 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -780,18 +811,18 @@ tr109:
   }
 	goto st18;
 tr115:
-#line 320 "unicorn_http.rl"
+#line 351 "unicorn_http.rl"
 	{MARK(start.query, p); }
-#line 321 "unicorn_http.rl"
+#line 352 "unicorn_http.rl"
 	{
-    VALIDATE_MAX_LENGTH(LEN(start.query, p), QUERY_STRING);
+    VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -805,16 +836,16 @@ tr115:
   }
 	goto st18;
 tr119:
-#line 321 "unicorn_http.rl"
+#line 352 "unicorn_http.rl"
 	{
-    VALIDATE_MAX_LENGTH(LEN(start.query, p), QUERY_STRING);
+    VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -831,12 +862,12 @@ st18:
 	if ( ++p == pe )
 		goto _test_eof18;
 case 18:
-#line 835 "unicorn_http.c"
+#line 866 "unicorn_http.c"
 	if ( (*p) == 10 )
 		goto tr28;
 	goto st0;
 tr28:
-#line 341 "unicorn_http.rl"
+#line 372 "unicorn_http.rl"
 	{
     finalize_header(hp);
 
@@ -860,23 +891,23 @@ st122:
 	if ( ++p == pe )
 		goto _test_eof122;
 case 122:
-#line 864 "unicorn_http.c"
+#line 895 "unicorn_http.c"
 	goto st0;
 tr22:
-#line 289 "unicorn_http.rl"
+#line 320 "unicorn_http.rl"
 	{ MARK(start.field, p); }
-#line 290 "unicorn_http.rl"
+#line 321 "unicorn_http.rl"
 	{ snake_upcase_char(deconst(p)); }
 	goto st19;
 tr29:
-#line 290 "unicorn_http.rl"
+#line 321 "unicorn_http.rl"
 	{ snake_upcase_char(deconst(p)); }
 	goto st19;
 st19:
 	if ( ++p == pe )
 		goto _test_eof19;
 case 19:
-#line 880 "unicorn_http.c"
+#line 911 "unicorn_http.c"
 	switch( (*p) ) {
 		case 33: goto tr29;
 		case 58: goto tr30;
@@ -902,18 +933,18 @@ case 19:
 		goto tr29;
 	goto st0;
 tr32:
-#line 293 "unicorn_http.rl"
+#line 324 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st20;
 tr30:
-#line 292 "unicorn_http.rl"
+#line 323 "unicorn_http.rl"
 	{ hp->s.field_len = LEN(start.field, p); }
 	goto st20;
 st20:
 	if ( ++p == pe )
 		goto _test_eof20;
 case 20:
-#line 917 "unicorn_http.c"
+#line 948 "unicorn_http.c"
 	switch( (*p) ) {
 		case 9: goto tr32;
 		case 13: goto tr33;
@@ -921,23 +952,23 @@ case 20:
 	}
 	goto tr31;
 tr31:
-#line 293 "unicorn_http.rl"
+#line 324 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st21;
 st21:
 	if ( ++p == pe )
 		goto _test_eof21;
 case 21:
-#line 932 "unicorn_http.c"
+#line 963 "unicorn_http.c"
 	if ( (*p) == 13 )
 		goto tr35;
 	goto st21;
 tr9:
-#line 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -951,22 +982,22 @@ tr9:
   }
 	goto st22;
 tr45:
-#line 326 "unicorn_http.rl"
+#line 357 "unicorn_http.rl"
 	{
     VALUE val;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_PATH);
+    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 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -980,18 +1011,18 @@ tr45:
   }
 	goto st22;
 tr51:
-#line 320 "unicorn_http.rl"
+#line 351 "unicorn_http.rl"
 	{MARK(start.query, p); }
-#line 321 "unicorn_http.rl"
+#line 352 "unicorn_http.rl"
 	{
-    VALIDATE_MAX_LENGTH(LEN(start.query, p), QUERY_STRING);
+    VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -1005,16 +1036,16 @@ tr51:
   }
 	goto st22;
 tr55:
-#line 321 "unicorn_http.rl"
+#line 352 "unicorn_http.rl"
 	{
-    VALIDATE_MAX_LENGTH(LEN(start.query, p), QUERY_STRING);
+    VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -1031,7 +1062,7 @@ st22:
 	if ( ++p == pe )
 		goto _test_eof22;
 case 22:
-#line 1035 "unicorn_http.c"
+#line 1066 "unicorn_http.c"
 	switch( (*p) ) {
 		case 32: goto tr37;
 		case 35: goto st0;
@@ -1042,14 +1073,14 @@ case 22:
 		goto st0;
 	goto tr36;
 tr36:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st23;
 st23:
 	if ( ++p == pe )
 		goto _test_eof23;
 case 23:
-#line 1053 "unicorn_http.c"
+#line 1084 "unicorn_http.c"
 	switch( (*p) ) {
 		case 32: goto tr40;
 		case 35: goto st0;
@@ -1060,14 +1091,14 @@ case 23:
 		goto st0;
 	goto st23;
 tr38:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st24;
 st24:
 	if ( ++p == pe )
 		goto _test_eof24;
 case 24:
-#line 1071 "unicorn_http.c"
+#line 1102 "unicorn_http.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto st25;
@@ -1091,20 +1122,20 @@ case 25:
 		goto st23;
 	goto st0;
 tr6:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st26;
 tr71:
-#line 300 "unicorn_http.rl"
+#line 331 "unicorn_http.rl"
 	{ rb_hash_aset(hp->env, g_http_host, STR_NEW(mark, p)); }
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st26;
 st26:
 	if ( ++p == pe )
 		goto _test_eof26;
 case 26:
-#line 1108 "unicorn_http.c"
+#line 1139 "unicorn_http.c"
 	switch( (*p) ) {
 		case 32: goto tr44;
 		case 35: goto tr45;
@@ -1142,11 +1173,11 @@ case 28:
 		goto st26;
 	goto st0;
 tr47:
-#line 326 "unicorn_http.rl"
+#line 357 "unicorn_http.rl"
 	{
     VALUE val;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_PATH);
+    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 */
@@ -1158,7 +1189,7 @@ st29:
 	if ( ++p == pe )
 		goto _test_eof29;
 case 29:
-#line 1162 "unicorn_http.c"
+#line 1193 "unicorn_http.c"
 	switch( (*p) ) {
 		case 32: goto tr50;
 		case 35: goto tr51;
@@ -1169,14 +1200,14 @@ case 29:
 		goto st0;
 	goto tr49;
 tr49:
-#line 320 "unicorn_http.rl"
+#line 351 "unicorn_http.rl"
 	{MARK(start.query, p); }
 	goto st30;
 st30:
 	if ( ++p == pe )
 		goto _test_eof30;
 case 30:
-#line 1180 "unicorn_http.c"
+#line 1211 "unicorn_http.c"
 	switch( (*p) ) {
 		case 32: goto tr54;
 		case 35: goto tr55;
@@ -1187,14 +1218,14 @@ case 30:
 		goto st0;
 	goto st30;
 tr52:
-#line 320 "unicorn_http.rl"
+#line 351 "unicorn_http.rl"
 	{MARK(start.query, p); }
 	goto st31;
 st31:
 	if ( ++p == pe )
 		goto _test_eof31;
 case 31:
-#line 1198 "unicorn_http.c"
+#line 1229 "unicorn_http.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto st32;
@@ -1218,58 +1249,58 @@ case 32:
 		goto st30;
 	goto st0;
 tr7:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
-#line 291 "unicorn_http.rl"
+#line 322 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st33;
 st33:
 	if ( ++p == pe )
 		goto _test_eof33;
 case 33:
-#line 1231 "unicorn_http.c"
+#line 1262 "unicorn_http.c"
 	switch( (*p) ) {
 		case 84: goto tr58;
 		case 116: goto tr58;
 	}
 	goto st0;
 tr58:
-#line 291 "unicorn_http.rl"
+#line 322 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st34;
 st34:
 	if ( ++p == pe )
 		goto _test_eof34;
 case 34:
-#line 1245 "unicorn_http.c"
+#line 1276 "unicorn_http.c"
 	switch( (*p) ) {
 		case 84: goto tr59;
 		case 116: goto tr59;
 	}
 	goto st0;
 tr59:
-#line 291 "unicorn_http.rl"
+#line 322 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st35;
 st35:
 	if ( ++p == pe )
 		goto _test_eof35;
 case 35:
-#line 1259 "unicorn_http.c"
+#line 1290 "unicorn_http.c"
 	switch( (*p) ) {
 		case 80: goto tr60;
 		case 112: goto tr60;
 	}
 	goto st0;
 tr60:
-#line 291 "unicorn_http.rl"
+#line 322 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st36;
 st36:
 	if ( ++p == pe )
 		goto _test_eof36;
 case 36:
-#line 1273 "unicorn_http.c"
+#line 1304 "unicorn_http.c"
 	switch( (*p) ) {
 		case 58: goto tr61;
 		case 83: goto tr62;
@@ -1277,7 +1308,7 @@ case 36:
 	}
 	goto st0;
 tr61:
-#line 297 "unicorn_http.rl"
+#line 328 "unicorn_http.rl"
 	{
     rb_hash_aset(hp->env, g_rack_url_scheme, STR_NEW(mark, p));
   }
@@ -1286,7 +1317,7 @@ st37:
 	if ( ++p == pe )
 		goto _test_eof37;
 case 37:
-#line 1290 "unicorn_http.c"
+#line 1321 "unicorn_http.c"
 	if ( (*p) == 47 )
 		goto st38;
 	goto st0;
@@ -1374,14 +1405,14 @@ case 42:
 		goto st40;
 	goto st0;
 tr67:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st43;
 st43:
 	if ( ++p == pe )
 		goto _test_eof43;
 case 43:
-#line 1385 "unicorn_http.c"
+#line 1416 "unicorn_http.c"
 	switch( (*p) ) {
 		case 37: goto st41;
 		case 47: goto tr71;
@@ -1433,14 +1464,14 @@ case 44:
 		goto st0;
 	goto st40;
 tr68:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st45;
 st45:
 	if ( ++p == pe )
 		goto _test_eof45;
 case 45:
-#line 1444 "unicorn_http.c"
+#line 1475 "unicorn_http.c"
 	switch( (*p) ) {
 		case 37: goto st41;
 		case 47: goto st0;
@@ -1518,14 +1549,14 @@ case 47:
 		goto st0;
 	goto st40;
 tr62:
-#line 291 "unicorn_http.rl"
+#line 322 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st48;
 st48:
 	if ( ++p == pe )
 		goto _test_eof48;
 case 48:
-#line 1529 "unicorn_http.c"
+#line 1560 "unicorn_http.c"
 	if ( (*p) == 58 )
 		goto tr61;
 	goto st0;
@@ -2041,14 +2072,14 @@ case 67:
 		goto tr3;
 	goto st0;
 tr2:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st68;
 st68:
 	if ( ++p == pe )
 		goto _test_eof68;
 case 68:
-#line 2052 "unicorn_http.c"
+#line 2083 "unicorn_http.c"
 	switch( (*p) ) {
 		case 32: goto tr3;
 		case 33: goto st49;
@@ -2132,14 +2163,14 @@ case 70:
 		goto st51;
 	goto st0;
 tr95:
-#line 296 "unicorn_http.rl"
+#line 327 "unicorn_http.rl"
 	{ request_method(hp, PTR_TO(mark), LEN(mark, p)); }
 	goto st71;
 st71:
 	if ( ++p == pe )
 		goto _test_eof71;
 case 71:
-#line 2143 "unicorn_http.c"
+#line 2174 "unicorn_http.c"
 	switch( (*p) ) {
 		case 42: goto tr96;
 		case 47: goto tr97;
@@ -2148,14 +2179,14 @@ case 71:
 	}
 	goto st0;
 tr96:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st72;
 st72:
 	if ( ++p == pe )
 		goto _test_eof72;
 case 72:
-#line 2159 "unicorn_http.c"
+#line 2190 "unicorn_http.c"
 	switch( (*p) ) {
 		case 13: goto tr99;
 		case 32: goto tr8;
@@ -2163,11 +2194,11 @@ case 72:
 	}
 	goto st0;
 tr100:
-#line 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -2181,22 +2212,22 @@ tr100:
   }
 	goto st73;
 tr110:
-#line 326 "unicorn_http.rl"
+#line 357 "unicorn_http.rl"
 	{
     VALUE val;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_PATH);
+    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 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -2210,18 +2241,18 @@ tr110:
   }
 	goto st73;
 tr116:
-#line 320 "unicorn_http.rl"
+#line 351 "unicorn_http.rl"
 	{MARK(start.query, p); }
-#line 321 "unicorn_http.rl"
+#line 352 "unicorn_http.rl"
 	{
-    VALIDATE_MAX_LENGTH(LEN(start.query, p), QUERY_STRING);
+    VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -2235,16 +2266,16 @@ tr116:
   }
 	goto st73;
 tr120:
-#line 321 "unicorn_http.rl"
+#line 352 "unicorn_http.rl"
 	{
-    VALIDATE_MAX_LENGTH(LEN(start.query, p), QUERY_STRING);
+    VALIDATE_MAX_URI_LENGTH(LEN(start.query, p), QUERY_STRING);
     rb_hash_aset(hp->env, g_query_string, STR_NEW(start.query, p));
   }
-#line 301 "unicorn_http.rl"
+#line 332 "unicorn_http.rl"
 	{
     VALUE str;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_URI);
+    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 '*'
@@ -2261,7 +2292,7 @@ st73:
 	if ( ++p == pe )
 		goto _test_eof73;
 case 73:
-#line 2265 "unicorn_http.c"
+#line 2296 "unicorn_http.c"
 	switch( (*p) ) {
 		case 13: goto tr102;
 		case 32: goto tr37;
@@ -2273,14 +2304,14 @@ case 73:
 		goto st0;
 	goto tr101;
 tr101:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st74;
 st74:
 	if ( ++p == pe )
 		goto _test_eof74;
 case 74:
-#line 2284 "unicorn_http.c"
+#line 2315 "unicorn_http.c"
 	switch( (*p) ) {
 		case 13: goto tr105;
 		case 32: goto tr40;
@@ -2292,14 +2323,14 @@ case 74:
 		goto st0;
 	goto st74;
 tr103:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st75;
 st75:
 	if ( ++p == pe )
 		goto _test_eof75;
 case 75:
-#line 2303 "unicorn_http.c"
+#line 2334 "unicorn_http.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto st76;
@@ -2323,20 +2354,20 @@ case 76:
 		goto st74;
 	goto st0;
 tr97:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st77;
 tr136:
-#line 300 "unicorn_http.rl"
+#line 331 "unicorn_http.rl"
 	{ rb_hash_aset(hp->env, g_http_host, STR_NEW(mark, p)); }
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st77;
 st77:
 	if ( ++p == pe )
 		goto _test_eof77;
 case 77:
-#line 2340 "unicorn_http.c"
+#line 2371 "unicorn_http.c"
 	switch( (*p) ) {
 		case 13: goto tr109;
 		case 32: goto tr44;
@@ -2375,11 +2406,11 @@ case 79:
 		goto st77;
 	goto st0;
 tr112:
-#line 326 "unicorn_http.rl"
+#line 357 "unicorn_http.rl"
 	{
     VALUE val;
 
-    VALIDATE_MAX_LENGTH(LEN(mark, p), REQUEST_PATH);
+    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 */
@@ -2391,7 +2422,7 @@ st80:
 	if ( ++p == pe )
 		goto _test_eof80;
 case 80:
-#line 2395 "unicorn_http.c"
+#line 2426 "unicorn_http.c"
 	switch( (*p) ) {
 		case 13: goto tr115;
 		case 32: goto tr50;
@@ -2403,14 +2434,14 @@ case 80:
 		goto st0;
 	goto tr114;
 tr114:
-#line 320 "unicorn_http.rl"
+#line 351 "unicorn_http.rl"
 	{MARK(start.query, p); }
 	goto st81;
 st81:
 	if ( ++p == pe )
 		goto _test_eof81;
 case 81:
-#line 2414 "unicorn_http.c"
+#line 2445 "unicorn_http.c"
 	switch( (*p) ) {
 		case 13: goto tr119;
 		case 32: goto tr54;
@@ -2422,14 +2453,14 @@ case 81:
 		goto st0;
 	goto st81;
 tr117:
-#line 320 "unicorn_http.rl"
+#line 351 "unicorn_http.rl"
 	{MARK(start.query, p); }
 	goto st82;
 st82:
 	if ( ++p == pe )
 		goto _test_eof82;
 case 82:
-#line 2433 "unicorn_http.c"
+#line 2464 "unicorn_http.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto st83;
@@ -2453,58 +2484,58 @@ case 83:
 		goto st81;
 	goto st0;
 tr98:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
-#line 291 "unicorn_http.rl"
+#line 322 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st84;
 st84:
 	if ( ++p == pe )
 		goto _test_eof84;
 case 84:
-#line 2466 "unicorn_http.c"
+#line 2497 "unicorn_http.c"
 	switch( (*p) ) {
 		case 84: goto tr123;
 		case 116: goto tr123;
 	}
 	goto st0;
 tr123:
-#line 291 "unicorn_http.rl"
+#line 322 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st85;
 st85:
 	if ( ++p == pe )
 		goto _test_eof85;
 case 85:
-#line 2480 "unicorn_http.c"
+#line 2511 "unicorn_http.c"
 	switch( (*p) ) {
 		case 84: goto tr124;
 		case 116: goto tr124;
 	}
 	goto st0;
 tr124:
-#line 291 "unicorn_http.rl"
+#line 322 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st86;
 st86:
 	if ( ++p == pe )
 		goto _test_eof86;
 case 86:
-#line 2494 "unicorn_http.c"
+#line 2525 "unicorn_http.c"
 	switch( (*p) ) {
 		case 80: goto tr125;
 		case 112: goto tr125;
 	}
 	goto st0;
 tr125:
-#line 291 "unicorn_http.rl"
+#line 322 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st87;
 st87:
 	if ( ++p == pe )
 		goto _test_eof87;
 case 87:
-#line 2508 "unicorn_http.c"
+#line 2539 "unicorn_http.c"
 	switch( (*p) ) {
 		case 58: goto tr126;
 		case 83: goto tr127;
@@ -2512,7 +2543,7 @@ case 87:
 	}
 	goto st0;
 tr126:
-#line 297 "unicorn_http.rl"
+#line 328 "unicorn_http.rl"
 	{
     rb_hash_aset(hp->env, g_rack_url_scheme, STR_NEW(mark, p));
   }
@@ -2521,7 +2552,7 @@ st88:
 	if ( ++p == pe )
 		goto _test_eof88;
 case 88:
-#line 2525 "unicorn_http.c"
+#line 2556 "unicorn_http.c"
 	if ( (*p) == 47 )
 		goto st89;
 	goto st0;
@@ -2609,14 +2640,14 @@ case 93:
 		goto st91;
 	goto st0;
 tr132:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st94;
 st94:
 	if ( ++p == pe )
 		goto _test_eof94;
 case 94:
-#line 2620 "unicorn_http.c"
+#line 2651 "unicorn_http.c"
 	switch( (*p) ) {
 		case 37: goto st92;
 		case 47: goto tr136;
@@ -2668,14 +2699,14 @@ case 95:
 		goto st0;
 	goto st91;
 tr133:
-#line 287 "unicorn_http.rl"
+#line 318 "unicorn_http.rl"
 	{MARK(mark, p); }
 	goto st96;
 st96:
 	if ( ++p == pe )
 		goto _test_eof96;
 case 96:
-#line 2679 "unicorn_http.c"
+#line 2710 "unicorn_http.c"
 	switch( (*p) ) {
 		case 37: goto st92;
 		case 47: goto st0;
@@ -2753,14 +2784,14 @@ case 98:
 		goto st0;
 	goto st91;
 tr127:
-#line 291 "unicorn_http.rl"
+#line 322 "unicorn_http.rl"
 	{ downcase_char(deconst(p)); }
 	goto st99;
 st99:
 	if ( ++p == pe )
 		goto _test_eof99;
 case 99:
-#line 2764 "unicorn_http.c"
+#line 2795 "unicorn_http.c"
 	if ( (*p) == 58 )
 		goto tr126;
 	goto st0;
@@ -2780,18 +2811,18 @@ case 100:
 		goto tr141;
 	goto st0;
 tr140:
-#line 336 "unicorn_http.rl"
+#line 367 "unicorn_http.rl"
 	{
     hp->len.chunk = step_incr(hp->len.chunk, (*p), 16);
     if (hp->len.chunk < 0)
-      parser_error("invalid chunk size");
+      parser_raise(eHttpParserError, "invalid chunk size");
   }
 	goto st101;
 st101:
 	if ( ++p == pe )
 		goto _test_eof101;
 case 101:
-#line 2795 "unicorn_http.c"
+#line 2826 "unicorn_http.c"
 	switch( (*p) ) {
 		case 13: goto st102;
 		case 48: goto tr140;
@@ -2814,7 +2845,7 @@ case 102:
 		goto tr144;
 	goto st0;
 tr144:
-#line 365 "unicorn_http.rl"
+#line 396 "unicorn_http.rl"
 	{
     HP_FL_SET(hp, INTRAILER);
     cs = http_parser_en_Trailers;
@@ -2827,21 +2858,21 @@ st123:
 	if ( ++p == pe )
 		goto _test_eof123;
 case 123:
-#line 2831 "unicorn_http.c"
+#line 2862 "unicorn_http.c"
 	goto st0;
 tr141:
-#line 336 "unicorn_http.rl"
+#line 367 "unicorn_http.rl"
 	{
     hp->len.chunk = step_incr(hp->len.chunk, (*p), 16);
     if (hp->len.chunk < 0)
-      parser_error("invalid chunk size");
+      parser_raise(eHttpParserError, "invalid chunk size");
   }
 	goto st103;
 st103:
 	if ( ++p == pe )
 		goto _test_eof103;
 case 103:
-#line 2845 "unicorn_http.c"
+#line 2876 "unicorn_http.c"
 	switch( (*p) ) {
 		case 13: goto st104;
 		case 59: goto st108;
@@ -2868,7 +2899,7 @@ st105:
 case 105:
 	goto tr148;
 tr148:
-#line 373 "unicorn_http.rl"
+#line 404 "unicorn_http.rl"
 	{
   skip_chunk_data_hack: {
     size_t nr = MIN((size_t)hp->len.chunk, REMAINING);
@@ -2890,7 +2921,7 @@ st106:
 	if ( ++p == pe )
 		goto _test_eof106;
 case 106:
-#line 2894 "unicorn_http.c"
+#line 2925 "unicorn_http.c"
 	if ( (*p) == 13 )
 		goto st107;
 	goto st0;
@@ -3112,14 +3143,14 @@ case 114:
 		goto tr157;
 	goto st0;
 tr159:
-#line 293 "unicorn_http.rl"
+#line 324 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st115;
 st115:
 	if ( ++p == pe )
 		goto _test_eof115;
 case 115:
-#line 3123 "unicorn_http.c"
+#line 3154 "unicorn_http.c"
 	switch( (*p) ) {
 		case 9: goto tr159;
 		case 13: goto tr160;
@@ -3127,42 +3158,42 @@ case 115:
 	}
 	goto tr158;
 tr158:
-#line 293 "unicorn_http.rl"
+#line 324 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st116;
 st116:
 	if ( ++p == pe )
 		goto _test_eof116;
 case 116:
-#line 3138 "unicorn_http.c"
+#line 3169 "unicorn_http.c"
 	if ( (*p) == 13 )
 		goto tr162;
 	goto st116;
 tr160:
-#line 293 "unicorn_http.rl"
+#line 324 "unicorn_http.rl"
 	{ MARK(mark, p); }
-#line 295 "unicorn_http.rl"
+#line 326 "unicorn_http.rl"
 	{ write_cont_value(hp, buffer, p); }
 	goto st117;
 tr162:
-#line 295 "unicorn_http.rl"
+#line 326 "unicorn_http.rl"
 	{ write_cont_value(hp, buffer, p); }
 	goto st117;
 tr169:
-#line 293 "unicorn_http.rl"
+#line 324 "unicorn_http.rl"
 	{ MARK(mark, p); }
-#line 294 "unicorn_http.rl"
+#line 325 "unicorn_http.rl"
 	{ write_value(hp, buffer, p); }
 	goto st117;
 tr171:
-#line 294 "unicorn_http.rl"
+#line 325 "unicorn_http.rl"
 	{ write_value(hp, buffer, p); }
 	goto st117;
 st117:
 	if ( ++p == pe )
 		goto _test_eof117;
 case 117:
-#line 3166 "unicorn_http.c"
+#line 3197 "unicorn_http.c"
 	if ( (*p) == 10 )
 		goto st114;
 	goto st0;
@@ -3174,7 +3205,7 @@ case 118:
 		goto tr164;
 	goto st0;
 tr164:
-#line 360 "unicorn_http.rl"
+#line 391 "unicorn_http.rl"
 	{
     cs = http_parser_first_final;
     goto post_exec;
@@ -3184,23 +3215,23 @@ st124:
 	if ( ++p == pe )
 		goto _test_eof124;
 case 124:
-#line 3188 "unicorn_http.c"
+#line 3219 "unicorn_http.c"
 	goto st0;
 tr157:
-#line 289 "unicorn_http.rl"
+#line 320 "unicorn_http.rl"
 	{ MARK(start.field, p); }
-#line 290 "unicorn_http.rl"
+#line 321 "unicorn_http.rl"
 	{ snake_upcase_char(deconst(p)); }
 	goto st119;
 tr165:
-#line 290 "unicorn_http.rl"
+#line 321 "unicorn_http.rl"
 	{ snake_upcase_char(deconst(p)); }
 	goto st119;
 st119:
 	if ( ++p == pe )
 		goto _test_eof119;
 case 119:
-#line 3204 "unicorn_http.c"
+#line 3235 "unicorn_http.c"
 	switch( (*p) ) {
 		case 33: goto tr165;
 		case 58: goto tr166;
@@ -3226,18 +3257,18 @@ case 119:
 		goto tr165;
 	goto st0;
 tr168:
-#line 293 "unicorn_http.rl"
+#line 324 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st120;
 tr166:
-#line 292 "unicorn_http.rl"
+#line 323 "unicorn_http.rl"
 	{ hp->s.field_len = LEN(start.field, p); }
 	goto st120;
 st120:
 	if ( ++p == pe )
 		goto _test_eof120;
 case 120:
-#line 3241 "unicorn_http.c"
+#line 3272 "unicorn_http.c"
 	switch( (*p) ) {
 		case 9: goto tr168;
 		case 13: goto tr169;
@@ -3245,14 +3276,14 @@ case 120:
 	}
 	goto tr167;
 tr167:
-#line 293 "unicorn_http.rl"
+#line 324 "unicorn_http.rl"
 	{ MARK(mark, p); }
 	goto st121;
 st121:
 	if ( ++p == pe )
 		goto _test_eof121;
 case 121:
-#line 3256 "unicorn_http.c"
+#line 3287 "unicorn_http.c"
 	if ( (*p) == 13 )
 		goto tr171;
 	goto st121;
@@ -3385,7 +3416,7 @@ case 121:
 	_out: {}
 	}
 
-#line 434 "unicorn_http.rl"
+#line 465 "unicorn_http.rl"
 post_exec: /* "_out:" also goes here */
   if (hp->cs != http_parser_error)
     hp->cs = cs;
@@ -3553,6 +3584,34 @@ static VALUE HttpParser_clear(VALUE self)
   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);
+
+  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;
+
+  return self;
+}
+
 /**
  * call-seq:
  *    parser.reset => nil
@@ -3632,7 +3691,8 @@ static VALUE HttpParser_parse(VALUE self)
   }
 
   http_parser_execute(hp, RSTRING_PTR(data), RSTRING_LEN(data));
-  VALIDATE_MAX_LENGTH(hp->offset, HEADER);
+  if (hp->offset > MAX_HEADER_LEN)
+    parser_raise(e413, "HTTP header is too large");
 
   if (hp->cs == http_parser_first_final ||
       hp->cs == http_parser_en_ChunkedBody) {
@@ -3645,11 +3705,32 @@ static VALUE HttpParser_parse(VALUE self)
   }
 
   if (hp->cs == http_parser_error)
-    parser_error("Invalid HTTP format, parsing fails.");
+    parser_raise(eHttpParserError, "Invalid HTTP format, parsing fails.");
 
   return Qnil;
 }
 
+/**
+ * Document-method: parse
+ * call-seq:
+ *    parser.add_parse(buffer) => env or nil
+ *
+ * adds the contents of +buffer+ to the internal buffer and attempts to
+ * continue parsing.  Returns the +env+ Hash on success or nil if more
+ * data is needed.
+ *
+ * Raises HttpParserError if there are parsing errors.
+ */
+static VALUE HttpParser_add_parse(VALUE self, VALUE buffer)
+{
+  struct http_parser *hp = data_get(self);
+
+  Check_Type(buffer, T_STRING);
+  rb_str_buf_append(hp->buf, buffer);
+
+  return HttpParser_parse(self);
+}
+
 /**
  * Document-method: trailers
  * call-seq:
@@ -3758,71 +3839,80 @@ static VALUE HttpParser_env(VALUE self)
 
 /**
  * call-seq:
- *    parser.filter_body(buf, data) => nil/data
+ *    parser.filter_body(dst, src) => nil/src
  *
- * Takes a String of +data+, will modify data if dechunking is done.
+ * Takes a String of +src+, will modify data if dechunking is done.
  * Returns +nil+ if there is more data left to process.  Returns
- * +data+ if body processing is complete. When returning +data+,
- * it may modify +data+ so the start of the string points to where
+ * +src+ if body processing is complete. When returning +src+,
+ * it may modify +src+ so the start of the string points to where
  * the body ended so that trailer processing can begin.
  *
  * Raises HttpParserError if there are dechunking errors.
- * Basically this is a glorified memcpy(3) that copies +data+
+ * Basically this is a glorified memcpy(3) that copies +src+
  * into +buf+ while filtering it through the dechunker.
  */
-static VALUE HttpParser_filter_body(VALUE self, VALUE buf, VALUE data)
+static VALUE HttpParser_filter_body(VALUE self, VALUE dst, VALUE src)
 {
   struct http_parser *hp = data_get(self);
-  char *dptr;
-  long dlen;
+  char *srcptr;
+  long srclen;
 
-  dptr = RSTRING_PTR(data);
-  dlen = RSTRING_LEN(data);
+  srcptr = RSTRING_PTR(src);
+  srclen = RSTRING_LEN(src);
 
-  StringValue(buf);
-  rb_str_resize(buf, dlen); /* we can never copy more than dlen bytes */
-  OBJ_TAINT(buf); /* keep weirdo $SAFE users happy */
+  StringValue(dst);
 
   if (HP_FL_TEST(hp, CHUNKED)) {
     if (!chunked_eof(hp)) {
+      rb_str_modify(dst);
+      rb_str_resize(dst, srclen); /* we can never copy more than srclen bytes */
+
       hp->s.dest_offset = 0;
-      hp->cont = buf;
-      hp->buf = data;
-      http_parser_execute(hp, dptr, dlen);
+      hp->cont = dst;
+      hp->buf = src;
+      http_parser_execute(hp, srcptr, srclen);
       if (hp->cs == http_parser_error)
-        parser_error("Invalid HTTP format, parsing fails.");
+        parser_raise(eHttpParserError, "Invalid HTTP format, parsing fails.");
 
       assert(hp->s.dest_offset <= hp->offset &&
              "destination buffer overflow");
-      advance_str(data, hp->offset);
-      rb_str_set_len(buf, hp->s.dest_offset);
+      advance_str(src, hp->offset);
+      rb_str_set_len(dst, hp->s.dest_offset);
 
-      if (RSTRING_LEN(buf) == 0 && chunked_eof(hp)) {
+      if (RSTRING_LEN(dst) == 0 && chunked_eof(hp)) {
         assert(hp->len.chunk == 0 && "chunk at EOF but more to parse");
       } else {
-        data = Qnil;
+        src = Qnil;
       }
     }
   } else {
     /* no need to enter the Ragel machine for unchunked transfers */
     assert(hp->len.content >= 0 && "negative Content-Length");
     if (hp->len.content > 0) {
-      long nr = MIN(dlen, hp->len.content);
-
-      hp->buf = data;
-      memcpy(RSTRING_PTR(buf), dptr, nr);
+      long nr = MIN(srclen, hp->len.content);
+
+      rb_str_modify(dst);
+      rb_str_resize(dst, nr);
+      /*
+       * using rb_str_replace() to avoid memcpy() doesn't help in
+       * most cases because a GC-aware programmer will pass an explicit
+       * buffer to env["rack.input"].read and reuse the buffer in a loop.
+       * This causes copy-on-write behavior to be triggered anyways
+       * when the +src+ buffer is modified (when reading off the socket).
+       */
+      hp->buf = src;
+      memcpy(RSTRING_PTR(dst), srcptr, nr);
       hp->len.content -= nr;
       if (hp->len.content == 0) {
         HP_FL_SET(hp, REQEOF);
         hp->cs = http_parser_first_final;
       }
-      advance_str(data, nr);
-      rb_str_set_len(buf, nr);
-      data = Qnil;
+      advance_str(src, nr);
+      src = Qnil;
     }
   }
   hp->offset = 0; /* for trailer parsing */
-  return data;
+  return src;
 }
 
 #define SET_GLOBAL(var,str) do { \
@@ -3838,13 +3928,19 @@ void Init_unicorn_http(void)
   cHttpParser = rb_define_class_under(mUnicorn, "HttpParser", rb_cObject);
   eHttpParserError =
          rb_define_class_under(mUnicorn, "HttpParserError", rb_eIOError);
+  e413 = rb_define_class_under(mUnicorn, "RequestEntityTooLargeError",
+                               eHttpParserError);
+  e414 = rb_define_class_under(mUnicorn, "RequestURITooLongError",
+                               eHttpParserError);
 
   init_globals();
   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);
   rb_define_method(cHttpParser, "trailers", HttpParser_headers, 2);
   rb_define_method(cHttpParser, "filter_body", HttpParser_filter_body, 2);
@@ -3879,6 +3975,7 @@ void Init_unicorn_http(void)
   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();
   SET_GLOBAL(g_http_host, "HOST");
@@ -3887,6 +3984,7 @@ void Init_unicorn_http(void)
   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");
   init_unicorn_httpdate();
 }
 #undef SET_GLOBAL