mongrel 1.1.5-x86-mingw32 → 1.2.0.pre2-x86-mingw32

data/History.txt

@@ -0,0 +1,68 @@
+=== 1.2.0.pre2 / 2010-03-18
+
+Improvements:
+
+* Ruby 1.9 early compatbility: Merged commits form Eric Wong and Matt Aimonetti.
+* Better RubyGems support thanks to added env she-bang to mongrel_rails executable.
+* Smartly load http11 extension using fat-binary approach.
+
+Bugfixes:
+
+* Fixed proper version reporting under 1.9
+* Consider MinGW as valid Windows platform.
+* Properly drop PID when daemonizing (EngineYard patched 1.1.5.1).
+
+Reorganization:
+
+* Rake task project reorganization and reformat using Hoe.
+* Compile extension using rake-compiler
+* Upgraded http11_parser to work with Ragel 6.2
+* Deprecated obsolete Windows service example scripts (from 2006!)
+* Relocate Http11 JRuby extension to share http11 C extension folder and name.
+
+=== 1.1.5 / 2008-05-22
+
+* Fix bug where num_processors is not actually set from mongrel_rails.
+
+
+=== 1.1.4 / 2008-02-29
+
+* Fix camping handler. Correct treatment of @throttle parameter.
+
+
+=== 1.1.3 / 2007-12-29
+
+* Fix security flaw of DirHandler; reported on mailing list.
+
+
+=== 1.1.2 /  2007-12-15
+
+* Fix worker termination bug; fix JRuby 1.0.3 load order issue; fix require issue on systems without Rubygems.
+
+
+=== 1.1.1 / 2007-11-12
+
+* Fix mongrel_rails restart bug; fix bug with Rack status codes.
+
+
+=== 1.1 / 2007-11-01
+
+* Pure Ruby URIClassifier.
+* More modular architecture.
+* JRuby support.
+* Move C URIClassifier into mongrel_experimental project.
+
+
+=== 1.0.4 / 2007-10-29
+
+* Backport fixes for versioning inconsistency, mongrel_rails bug, and DirHandler bug.
+
+
+=== 1.0.3
+
+* Fix user-switching bug; make people upgrade to the latest from the RC.
+
+
+=== 1.0.2
+
+* Signed gem; many minor bugfixes and patches.

data/{Manifest → Manifest.txt}

@@ -1,15 +1,18 @@
-bin/mongrel_rails
-CHANGELOG
 COPYING
+History.txt
+LICENSE
+Manifest.txt
+README.txt
+Rakefile
+TODO
+bin/mongrel_rails
 examples/builder.rb
-examples/camping/blog.rb
 examples/camping/README
+examples/camping/blog.rb
 examples/camping/tepee.rb
 examples/httpd.conf
 examples/mime.yaml
 examples/mongrel.conf
-examples/mongrel_simple_ctrl.rb
-examples/mongrel_simple_service.rb
 examples/monitrc
 examples/random_thrash.rb
 examples/simpletest.rb
@@ -22,9 +25,10 @@ ext/http11/http11_parser.h
 ext/http11/http11_parser.java.rl
 ext/http11/http11_parser.rl
 ext/http11/http11_parser_common.rl
-ext/http11_java/Http11Service.java
-ext/http11_java/org/jruby/mongrel/Http11.java
-ext/http11_java/org/jruby/mongrel/Http11Parser.java
+ext/http11/Http11Service.java
+ext/http11/org/jruby/mongrel/Http11.java
+ext/http11/org/jruby/mongrel/Http11Parser.java
+lib/mongrel.rb
 lib/mongrel/camping.rb
 lib/mongrel/cgi.rb
 lib/mongrel/command.rb
@@ -42,13 +46,10 @@ lib/mongrel/rails.rb
 lib/mongrel/stats.rb
 lib/mongrel/tcphack.rb
 lib/mongrel/uri_classifier.rb
-lib/mongrel.rb
-LICENSE
-Manifest
-mongrel-public_cert.pem
-mongrel.gemspec
-README
 setup.rb
+tasks/gem.rake
+tasks/native.rake
+tasks/ragel.rake
 test/mime.yaml
 test/mongrel.conf
 test/test_cgi_wrapper.rb
@@ -65,5 +66,4 @@ test/test_stats.rb
 test/test_uriclassifier.rb
 test/test_ws.rb
 test/testhelp.rb
-TODO
 tools/trickletest.rb

data/{README → README.txt}

@@ -1,5 +1,11 @@
 = Mongrel:  Simple Fast Mostly Ruby Web Server
 
+* http://mongrel.rubyforge.org/
+* http://rubyforge.org/projects/mongrel
+* http://github.com/luislavena/mongrel
+
+== Description
+
 Mongrel is a small library that provides a very fast HTTP 1.1 server for Ruby web applications.  It is not particular to any framework, and is intended to be just enough to get a web application running behind a more complete and robust web server.
 
 What makes Mongrel so fast is the careful use of an Ragel extension to provide fast, accurate HTTP 1.1 protocol parsing. This makes the server scream without too many portability issues.

data/Rakefile

@@ -0,0 +1,8 @@
+#
+# NOTE: Keep this file clean.
+# Add your customizations inside tasks directory.
+# Thank You.
+#
+
+# load rakefile extensions (tasks)
+Dir['tasks/*.rake'].sort.each { |f| load f }

data/bin/mongrel_rails

@@ -1,3 +1,5 @@
+#!/usr/bin/env ruby
+#
 # Copyright (c) 2005 Zed A. Shaw
 # You can redistribute it and/or modify it under the same terms as Ruby.
 #
@@ -90,6 +92,7 @@ module Mongrel
           end
 
           daemonize
+          write_pid_file
           log "Daemonized, any open files are closed.  Look at #{defaults[:pid_file]} and #{defaults[:log_file]} for info."
           log "Settings loaded from #{@config_file} (they override command line)." if @config_file
         end
@@ -128,9 +131,7 @@ module Mongrel
       config.run
       config.log "Mongrel #{Mongrel::Const::MONGREL_VERSION} available at #{@address}:#{@port}"
 
-      if config.defaults[:daemon]
-        config.write_pid_file
-      else
+      unless config.defaults[:daemon]
         config.log "Use CTRL-C to stop." 
       end
 
@@ -194,7 +195,7 @@ module Mongrel
   end
 
   def Mongrel::send_signal(signal, pid_file)
-    pid = open(pid_file).read.to_i
+    pid = File.read(pid_file).to_i 
     print "Sending #{signal} to Mongrel at PID #{pid}..."
     begin
       Process.kill(signal, pid)

data/ext/http11/ext_help.h

@@ -4,6 +4,7 @@
 #define RAISE_NOT_NULL(T) if(T == NULL) rb_raise(rb_eArgError, "NULL found for " # T " when shouldn't be.");
 #define DATA_GET(from,type,name) Data_Get_Struct(from,type,name); RAISE_NOT_NULL(name);
 #define REQUIRE_TYPE(V, T) if(TYPE(V) != T) rb_raise(rb_eTypeError, "Wrong argument type for " # V " required " # T);
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
 
 #ifdef DEBUG
 #define TRACE()  fprintf(stderr, "> %s:%d:%s\n", __FILE__, __LINE__, __FUNCTION__)

data/ext/http11/http11.c

@@ -7,7 +7,20 @@
 #include <assert.h>
 #include <string.h>
 #include "http11_parser.h"
-#include <ctype.h>
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
 
 static VALUE mMongrel;
 static VALUE cHttpParser;
@@ -15,8 +28,9 @@ static VALUE eHttpParserError;
 
 #define id_handler_map rb_intern("@handler_map")
 #define id_http_body rb_intern("@http_body")
+#define HTTP_PREFIX "HTTP_"
+#define HTTP_PREFIX_LEN (sizeof(HTTP_PREFIX) - 1)
 
-static VALUE global_http_prefix;
 static VALUE global_request_method;
 static VALUE global_request_uri;
 static VALUE global_fragment;
@@ -59,10 +73,119 @@ DEF_MAX_LENGTH(REQUEST_PATH, 1024);
 DEF_MAX_LENGTH(QUERY_STRING, (1024 * 10));
 DEF_MAX_LENGTH(HEADER, (1024 * (80 + 32)));
 
+struct common_field {
+	const signed long len;
+	const char *name;
+	VALUE value;
+};
+
+/*
+ * A list of common HTTP headers we expect to receive.
+ * This allows us to avoid repeatedly creating identical string
+ * objects to be used with rb_hash_aset().
+ */
+static struct common_field common_http_fields[] = {
+# define f(N) { (sizeof(N) - 1), N, Qnil }
+	f("ACCEPT"),
+	f("ACCEPT_CHARSET"),
+	f("ACCEPT_ENCODING"),
+	f("ACCEPT_LANGUAGE"),
+	f("ALLOW"),
+	f("AUTHORIZATION"),
+	f("CACHE_CONTROL"),
+	f("CONNECTION"),
+	f("CONTENT_ENCODING"),
+	f("CONTENT_LENGTH"),
+	f("CONTENT_TYPE"),
+	f("COOKIE"),
+	f("DATE"),
+	f("EXPECT"),
+	f("FROM"),
+	f("HOST"),
+	f("IF_MATCH"),
+	f("IF_MODIFIED_SINCE"),
+	f("IF_NONE_MATCH"),
+	f("IF_RANGE"),
+	f("IF_UNMODIFIED_SINCE"),
+	f("KEEP_ALIVE"), /* Firefox sends this */
+	f("MAX_FORWARDS"),
+	f("PRAGMA"),
+	f("PROXY_AUTHORIZATION"),
+	f("RANGE"),
+	f("REFERER"),
+	f("TE"),
+	f("TRAILER"),
+	f("TRANSFER_ENCODING"),
+	f("UPGRADE"),
+	f("USER_AGENT"),
+	f("VIA"),
+	f("X_FORWARDED_FOR"), /* common for proxies */
+	f("X_REAL_IP"), /* common for proxies */
+	f("WARNING")
+# undef f
+};
+
+/*
+ * qsort(3) and bsearch(3) improve average performance slightly, but may
+ * not be worth it for lack of portability to certain platforms...
+ */
+#if defined(HAVE_QSORT_BSEARCH)
+/* sort by length, then by name if there's a tie */
+static int common_field_cmp(const void *a, const void *b)
+{
+  struct common_field *cfa = (struct common_field *)a;
+  struct common_field *cfb = (struct common_field *)b;
+  signed long diff = cfa->len - cfb->len;
+  return diff ? diff : memcmp(cfa->name, cfb->name, cfa->len);
+}
+#endif /* HAVE_QSORT_BSEARCH */
+
+static void init_common_fields(void)
+{
+  int i;
+  struct common_field *cf = common_http_fields;
+  char tmp[256]; /* MAX_FIELD_NAME_LENGTH */
+  memcpy(tmp, HTTP_PREFIX, HTTP_PREFIX_LEN);
+
+  for(i = 0; i < ARRAY_SIZE(common_http_fields); cf++, i++) {
+    memcpy(tmp + HTTP_PREFIX_LEN, cf->name, cf->len + 1);
+    cf->value = rb_obj_freeze(rb_str_new(tmp, HTTP_PREFIX_LEN + cf->len));
+    rb_global_variable(&cf->value);
+  }
+
+#if defined(HAVE_QSORT_BSEARCH)
+  qsort(common_http_fields,
+        ARRAY_SIZE(common_http_fields),
+        sizeof(struct common_field),
+        common_field_cmp);
+#endif /* HAVE_QSORT_BSEARCH */
+}
+
+static VALUE find_common_field_value(const char *field, size_t flen)
+{
+#if defined(HAVE_QSORT_BSEARCH)
+  struct common_field key;
+  struct common_field *found;
+  key.name = field;
+  key.len = (signed long)flen;
+  found = (struct common_field *)bsearch(&key, common_http_fields,
+                                         ARRAY_SIZE(common_http_fields),
+                                         sizeof(struct common_field),
+                                         common_field_cmp);
+  return found ? found->value : Qnil;
+#else /* !HAVE_QSORT_BSEARCH */
+  int i;
+  struct common_field *cf = common_http_fields;
+  for(i = 0; i < ARRAY_SIZE(common_http_fields); i++, cf++) {
+    if (cf->len == flen && !memcmp(cf->name, field, flen))
+      return cf->value;
+  }
+  return Qnil;
+#endif /* !HAVE_QSORT_BSEARCH */
+}
 
 void http_field(void *data, const char *field, size_t flen, const char *value, size_t vlen)
 {
-  char *ch, *end;
   VALUE req = (VALUE)data;
   VALUE v = Qnil;
   VALUE f = Qnil;
@@ -71,15 +194,25 @@ void http_field(void *data, const char *field, size_t flen, const char *value, s
   VALIDATE_MAX_LENGTH(vlen, FIELD_VALUE);
 
   v = rb_str_new(value, vlen);
-  f = rb_str_dup(global_http_prefix);
-  f = rb_str_buf_cat(f, field, flen); 
 
-  for(ch = RSTRING(f)->ptr, end = ch + RSTRING(f)->len; ch < end; ch++) {
-    if(*ch == '-') {
-      *ch = '_';
-    } else {
-      *ch = toupper(*ch);
-    }
+  f = find_common_field_value(field, flen);
+
+  if (f == Qnil) {
+    /*
+     * We got a strange header that we don't have a memoized value for.
+     * Fallback to creating a new string to use as a hash key.
+     *
+     * using rb_str_new(NULL, len) here is faster than rb_str_buf_new(len)
+     * in my testing, because: there's no minimum allocation length (and
+     * no check for it, either), RSTRING_LEN(f) does not need to be
+     * written twice, and and RSTRING_PTR(f) will already be
+     * null-terminated for us.
+     */
+    f = rb_str_new(NULL, HTTP_PREFIX_LEN + flen);
+    memcpy(RSTRING_PTR(f), HTTP_PREFIX, HTTP_PREFIX_LEN);
+    memcpy(RSTRING_PTR(f) + HTTP_PREFIX_LEN, field, flen);
+    assert(*(RSTRING_PTR(f) + RSTRING_LEN(f)) == '\0'); /* paranoia */
+    /* fprintf(stderr, "UNKNOWN HEADER <%s>\n", RSTRING_PTR(f)); */
   }
 
   rb_hash_aset(req, f, v);
@@ -168,13 +301,12 @@ void header_done(void *data, const char *at, size_t length)
 
   rb_hash_aset(req, global_gateway_interface, global_gateway_interface_value);
   if((temp = rb_hash_aref(req, global_http_host)) != Qnil) {
-    /* ruby better close strings off with a '\0' dammit */
-    colon = strchr(RSTRING(temp)->ptr, ':');
+    colon = memchr(RSTRING_PTR(temp), ':', RSTRING_LEN(temp));
     if(colon != NULL) {
-      rb_hash_aset(req, global_server_name, rb_str_substr(temp, 0, colon - RSTRING(temp)->ptr));
+      rb_hash_aset(req, global_server_name, rb_str_substr(temp, 0, colon - RSTRING_PTR(temp)));
       rb_hash_aset(req, global_server_port, 
-          rb_str_substr(temp, colon - RSTRING(temp)->ptr+1, 
-            RSTRING(temp)->len));
+          rb_str_substr(temp, colon - RSTRING_PTR(temp)+1, 
+            RSTRING_LEN(temp)));
     } else {
       rb_hash_aset(req, global_server_name, temp);
       rb_hash_aset(req, global_server_port, global_port_80);
@@ -295,8 +427,8 @@ VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
   DATA_GET(self, http_parser, http);
 
   from = FIX2INT(start);
-  dptr = RSTRING(data)->ptr;
-  dlen = RSTRING(data)->len;
+  dptr = RSTRING_PTR(data);
+  dlen = RSTRING_LEN(data);
 
   if(from >= dlen) {
     rb_raise(eHttpParserError, "Requested start is after data buffer end.");
@@ -366,7 +498,6 @@ void Init_http11()
 
   mMongrel = rb_define_module("Mongrel");
 
-  DEF_GLOBAL(http_prefix, "HTTP_");
   DEF_GLOBAL(request_method, "REQUEST_METHOD");
   DEF_GLOBAL(request_uri, "REQUEST_URI");
   DEF_GLOBAL(fragment, "FRAGMENT");
@@ -384,7 +515,7 @@ void Init_http11()
   DEF_GLOBAL(server_protocol, "SERVER_PROTOCOL");
   DEF_GLOBAL(server_protocol_value, "HTTP/1.1");
   DEF_GLOBAL(http_host, "HTTP_HOST");
-  DEF_GLOBAL(mongrel_version, "Mongrel 1.1.5"); /* XXX Why is this defined here? */
+  DEF_GLOBAL(mongrel_version, "Mongrel 1.2.0.pre2"); /* XXX Why is this defined here? */
   DEF_GLOBAL(server_software, "SERVER_SOFTWARE");
   DEF_GLOBAL(port_80, "80");
 
@@ -399,4 +530,5 @@ void Init_http11()
   rb_define_method(cHttpParser, "error?", HttpParser_has_error,0);
   rb_define_method(cHttpParser, "finished?", HttpParser_is_finished,0);
   rb_define_method(cHttpParser, "nread", HttpParser_nread,0);
+  init_common_fields();
 }

data/ext/http11/http11_parser.c

@@ -1,4 +1,4 @@
-#line 1 "http11_parser.rl"
+#line 1 "ext/http11/http11_parser.rl"
 /**
  * Copyright (c) 2005 Zed A. Shaw
  * You can redistribute it and/or modify it under the same terms as Ruby.
@@ -10,34 +10,46 @@
 #include <ctype.h>
 #include <string.h>
 
+/*
+ * capitalizes all lower-case ASCII characters,
+ * converts dashes to underscores.
+ */
+static void snake_upcase_char(char *c)
+{
+    if (*c >= 'a' && *c <= 'z')
+      *c &= ~0x20;
+    else if (*c == '-')
+      *c = '_';
+}
+
 #define LEN(AT, FPC) (FPC - buffer - parser->AT)
 #define MARK(M,FPC) (parser->M = (FPC) - buffer)
 #define PTR_TO(F) (buffer + parser->F)
 
 /** Machine **/
 
-#line 74 "http11_parser.rl"
+#line 87 "ext/http11/http11_parser.rl"
 
 
 /** Data **/
 
-#line 25 "http11_parser.c"
+#line 37 "ext/http11/http11_parser.c"
 static const int http_parser_start = 1;
 static const int http_parser_first_final = 57;
 static const int http_parser_error = 0;
 
 static const int http_parser_en_main = 1;
 
-#line 78 "http11_parser.rl"
+#line 91 "ext/http11/http11_parser.rl"
 
 int http_parser_init(http_parser *parser)  {
   int cs = 0;
   
-#line 37 "http11_parser.c"
+#line 49 "ext/http11/http11_parser.c"
 	{
 	cs = http_parser_start;
 	}
-#line 82 "http11_parser.rl"
+#line 95 "ext/http11/http11_parser.rl"
   parser->cs = cs;
   parser->body_start = 0;
   parser->content_len = 0;
@@ -60,15 +72,14 @@ size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len,
   p = buffer+off;
   pe = buffer+len;
 
-  assert(*pe == '\0' && "pointer does not end on NUL");
+  /* assert(*pe == '\0' && "pointer does not end on NUL"); */
   assert(pe - p == len - off && "pointers aren't same distance");
 
-
   
-#line 69 "http11_parser.c"
+#line 80 "ext/http11/http11_parser.c"
 	{
 	if ( p == pe )
-		goto _out;
+		goto _test_eof;
 	switch ( cs )
 	{
 case 1:
@@ -86,16 +97,17 @@ case 1:
 		goto tr0;
 	goto st0;
 st0:
-	goto _out0;
+cs = 0;
+	goto _out;
 tr0:
-#line 22 "http11_parser.rl"
+#line 34 "ext/http11/http11_parser.rl"
 	{MARK(mark, p); }
 	goto st2;
 st2:
 	if ( ++p == pe )
-		goto _out2;
+		goto _test_eof2;
 case 2:
-#line 99 "http11_parser.c"
+#line 111 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 32: goto tr2;
 		case 36: goto st38;
@@ -111,7 +123,7 @@ case 2:
 		goto st38;
 	goto st0;
 tr2:
-#line 36 "http11_parser.rl"
+#line 49 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->request_method != NULL) 
       parser->request_method(parser->data, PTR_TO(mark), LEN(mark, p));
@@ -119,9 +131,9 @@ tr2:
 	goto st3;
 st3:
 	if ( ++p == pe )
-		goto _out3;
+		goto _test_eof3;
 case 3:
-#line 125 "http11_parser.c"
+#line 137 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 42: goto tr4;
 		case 43: goto tr5;
@@ -138,66 +150,75 @@ case 3:
 		goto tr5;
 	goto st0;
 tr4:
-#line 22 "http11_parser.rl"
+#line 34 "ext/http11/http11_parser.rl"
 	{MARK(mark, p); }
 	goto st4;
 st4:
 	if ( ++p == pe )
-		goto _out4;
+		goto _test_eof4;
 case 4:
-#line 149 "http11_parser.c"
+#line 161 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 32: goto tr8;
 		case 35: goto tr9;
 	}
 	goto st0;
 tr8:
-#line 40 "http11_parser.rl"
+#line 53 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st5;
-tr30:
-#line 44 "http11_parser.rl"
-	{ 
+tr31:
+#line 34 "ext/http11/http11_parser.rl"
+	{MARK(mark, p); }
+#line 57 "ext/http11/http11_parser.rl"
+	{
     if(parser->fragment != NULL)
       parser->fragment(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st5;
-tr40:
-#line 60 "http11_parser.rl"
+tr34:
+#line 57 "ext/http11/http11_parser.rl"
+	{
+    if(parser->fragment != NULL)
+      parser->fragment(parser->data, PTR_TO(mark), LEN(mark, p));
+  }
+	goto st5;
+tr42:
+#line 73 "ext/http11/http11_parser.rl"
 	{
     if(parser->request_path != NULL)
       parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
   }
-#line 40 "http11_parser.rl"
+#line 53 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st5;
-tr51:
-#line 49 "http11_parser.rl"
+tr53:
+#line 62 "ext/http11/http11_parser.rl"
 	{MARK(query_start, p); }
-#line 50 "http11_parser.rl"
+#line 63 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->query_string != NULL)
       parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, p));
   }
-#line 40 "http11_parser.rl"
+#line 53 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st5;
-tr55:
-#line 50 "http11_parser.rl"
+tr57:
+#line 63 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->query_string != NULL)
       parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, p));
   }
-#line 40 "http11_parser.rl"
+#line 53 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
@@ -205,55 +226,55 @@ tr55:
 	goto st5;
 st5:
 	if ( ++p == pe )
-		goto _out5;
+		goto _test_eof5;
 case 5:
-#line 211 "http11_parser.c"
+#line 232 "ext/http11/http11_parser.c"
 	if ( (*p) == 72 )
 		goto tr10;
 	goto st0;
 tr10:
-#line 22 "http11_parser.rl"
+#line 34 "ext/http11/http11_parser.rl"
 	{MARK(mark, p); }
 	goto st6;
 st6:
 	if ( ++p == pe )
-		goto _out6;
+		goto _test_eof6;
 case 6:
-#line 223 "http11_parser.c"
+#line 244 "ext/http11/http11_parser.c"
 	if ( (*p) == 84 )
 		goto st7;
 	goto st0;
 st7:
 	if ( ++p == pe )
-		goto _out7;
+		goto _test_eof7;
 case 7:
 	if ( (*p) == 84 )
 		goto st8;
 	goto st0;
 st8:
 	if ( ++p == pe )
-		goto _out8;
+		goto _test_eof8;
 case 8:
 	if ( (*p) == 80 )
 		goto st9;
 	goto st0;
 st9:
 	if ( ++p == pe )
-		goto _out9;
+		goto _test_eof9;
 case 9:
 	if ( (*p) == 47 )
 		goto st10;
 	goto st0;
 st10:
 	if ( ++p == pe )
-		goto _out10;
+		goto _test_eof10;
 case 10:
 	if ( 48 <= (*p) && (*p) <= 57 )
 		goto st11;
 	goto st0;
 st11:
 	if ( ++p == pe )
-		goto _out11;
+		goto _test_eof11;
 case 11:
 	if ( (*p) == 46 )
 		goto st12;
@@ -262,14 +283,14 @@ case 11:
 	goto st0;
 st12:
 	if ( ++p == pe )
-		goto _out12;
+		goto _test_eof12;
 case 12:
 	if ( 48 <= (*p) && (*p) <= 57 )
 		goto st13;
 	goto st0;
 st13:
 	if ( ++p == pe )
-		goto _out13;
+		goto _test_eof13;
 case 13:
 	if ( (*p) == 13 )
 		goto tr18;
@@ -277,15 +298,25 @@ case 13:
 		goto st13;
 	goto st0;
 tr18:
-#line 55 "http11_parser.rl"
+#line 68 "ext/http11/http11_parser.rl"
 	{	
     if(parser->http_version != NULL)
       parser->http_version(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st14;
 tr26:
-#line 31 "http11_parser.rl"
-	{ 
+#line 43 "ext/http11/http11_parser.rl"
+	{ MARK(mark, p); }
+#line 44 "ext/http11/http11_parser.rl"
+	{
+    if(parser->http_field != NULL) {
+      parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
+    }
+  }
+	goto st14;
+tr29:
+#line 44 "ext/http11/http11_parser.rl"
+	{
     if(parser->http_field != NULL) {
       parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, p));
     }
@@ -293,15 +324,15 @@ tr26:
 	goto st14;
 st14:
 	if ( ++p == pe )
-		goto _out14;
+		goto _test_eof14;
 case 14:
-#line 299 "http11_parser.c"
+#line 330 "ext/http11/http11_parser.c"
 	if ( (*p) == 10 )
 		goto st15;
 	goto st0;
 st15:
 	if ( ++p == pe )
-		goto _out15;
+		goto _test_eof15;
 case 15:
 	switch( (*p) ) {
 		case 13: goto st16;
@@ -329,131 +360,137 @@ case 15:
 	goto st0;
 st16:
 	if ( ++p == pe )
-		goto _out16;
+		goto _test_eof16;
 case 16:
 	if ( (*p) == 10 )
 		goto tr22;
 	goto st0;
 tr22:
-#line 65 "http11_parser.rl"
+#line 78 "ext/http11/http11_parser.rl"
 	{ 
     parser->body_start = p - buffer + 1; 
     if(parser->header_done != NULL)
       parser->header_done(parser->data, p + 1, pe - p - 1);
-    goto _out57;
+    {p++; cs = 57; goto _out;}
   }
 	goto st57;
 st57:
 	if ( ++p == pe )
-		goto _out57;
+		goto _test_eof57;
 case 57:
-#line 351 "http11_parser.c"
+#line 382 "ext/http11/http11_parser.c"
 	goto st0;
 tr21:
-#line 25 "http11_parser.rl"
+#line 37 "ext/http11/http11_parser.rl"
 	{ MARK(field_start, p); }
+#line 38 "ext/http11/http11_parser.rl"
+	{ snake_upcase_char((char *)p); }
+	goto st17;
+tr23:
+#line 38 "ext/http11/http11_parser.rl"
+	{ snake_upcase_char((char *)p); }
 	goto st17;
 st17:
 	if ( ++p == pe )
-		goto _out17;
+		goto _test_eof17;
 case 17:
-#line 361 "http11_parser.c"
+#line 398 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
-		case 33: goto st17;
+		case 33: goto tr23;
 		case 58: goto tr24;
-		case 124: goto st17;
-		case 126: goto st17;
+		case 124: goto tr23;
+		case 126: goto tr23;
 	}
 	if ( (*p) < 45 ) {
 		if ( (*p) > 39 ) {
 			if ( 42 <= (*p) && (*p) <= 43 )
-				goto st17;
+				goto tr23;
 		} else if ( (*p) >= 35 )
-			goto st17;
+			goto tr23;
 	} else if ( (*p) > 46 ) {
 		if ( (*p) < 65 ) {
 			if ( 48 <= (*p) && (*p) <= 57 )
-				goto st17;
+				goto tr23;
 		} else if ( (*p) > 90 ) {
 			if ( 94 <= (*p) && (*p) <= 122 )
-				goto st17;
+				goto tr23;
 		} else
-			goto st17;
+			goto tr23;
 	} else
-		goto st17;
+		goto tr23;
 	goto st0;
 tr24:
-#line 26 "http11_parser.rl"
+#line 39 "ext/http11/http11_parser.rl"
 	{ 
     parser->field_len = LEN(field_start, p);
   }
 	goto st18;
 tr27:
-#line 30 "http11_parser.rl"
+#line 43 "ext/http11/http11_parser.rl"
 	{ MARK(mark, p); }
 	goto st18;
 st18:
 	if ( ++p == pe )
-		goto _out18;
+		goto _test_eof18;
 case 18:
-#line 400 "http11_parser.c"
+#line 437 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 13: goto tr26;
 		case 32: goto tr27;
 	}
 	goto tr25;
 tr25:
-#line 30 "http11_parser.rl"
+#line 43 "ext/http11/http11_parser.rl"
 	{ MARK(mark, p); }
 	goto st19;
 st19:
 	if ( ++p == pe )
-		goto _out19;
+		goto _test_eof19;
 case 19:
-#line 414 "http11_parser.c"
+#line 451 "ext/http11/http11_parser.c"
 	if ( (*p) == 13 )
-		goto tr26;
+		goto tr29;
 	goto st19;
 tr9:
-#line 40 "http11_parser.rl"
+#line 53 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st20;
-tr41:
-#line 60 "http11_parser.rl"
+tr43:
+#line 73 "ext/http11/http11_parser.rl"
 	{
     if(parser->request_path != NULL)
       parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
   }
-#line 40 "http11_parser.rl"
+#line 53 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st20;
-tr52:
-#line 49 "http11_parser.rl"
+tr54:
+#line 62 "ext/http11/http11_parser.rl"
 	{MARK(query_start, p); }
-#line 50 "http11_parser.rl"
+#line 63 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->query_string != NULL)
       parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, p));
   }
-#line 40 "http11_parser.rl"
+#line 53 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
   }
 	goto st20;
-tr56:
-#line 50 "http11_parser.rl"
+tr58:
+#line 63 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->query_string != NULL)
       parser->query_string(parser->data, PTR_TO(query_start), LEN(query_start, p));
   }
-#line 40 "http11_parser.rl"
+#line 53 "ext/http11/http11_parser.rl"
 	{ 
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
@@ -461,12 +498,12 @@ tr56:
 	goto st20;
 st20:
 	if ( ++p == pe )
-		goto _out20;
+		goto _test_eof20;
 case 20:
-#line 467 "http11_parser.c"
+#line 504 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
-		case 32: goto tr30;
-		case 37: goto tr31;
+		case 32: goto tr31;
+		case 37: goto tr32;
 		case 60: goto st0;
 		case 62: goto st0;
 		case 127: goto st0;
@@ -476,18 +513,18 @@ case 20:
 			goto st0;
 	} else if ( (*p) >= 0 )
 		goto st0;
-	goto tr29;
-tr29:
-#line 22 "http11_parser.rl"
+	goto tr30;
+tr30:
+#line 34 "ext/http11/http11_parser.rl"
 	{MARK(mark, p); }
 	goto st21;
 st21:
 	if ( ++p == pe )
-		goto _out21;
+		goto _test_eof21;
 case 21:
-#line 489 "http11_parser.c"
+#line 526 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
-		case 32: goto tr30;
+		case 32: goto tr34;
 		case 37: goto st22;
 		case 60: goto st0;
 		case 62: goto st0;
@@ -499,15 +536,15 @@ case 21:
 	} else if ( (*p) >= 0 )
 		goto st0;
 	goto st21;
-tr31:
-#line 22 "http11_parser.rl"
+tr32:
+#line 34 "ext/http11/http11_parser.rl"
 	{MARK(mark, p); }
 	goto st22;
 st22:
 	if ( ++p == pe )
-		goto _out22;
+		goto _test_eof22;
 case 22:
-#line 511 "http11_parser.c"
+#line 548 "ext/http11/http11_parser.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto st23;
@@ -519,7 +556,7 @@ case 22:
 	goto st0;
 st23:
 	if ( ++p == pe )
-		goto _out23;
+		goto _test_eof23;
 case 23:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
@@ -531,14 +568,14 @@ case 23:
 		goto st21;
 	goto st0;
 tr5:
-#line 22 "http11_parser.rl"
+#line 34 "ext/http11/http11_parser.rl"
 	{MARK(mark, p); }
 	goto st24;
 st24:
 	if ( ++p == pe )
-		goto _out24;
+		goto _test_eof24;
 case 24:
-#line 542 "http11_parser.c"
+#line 579 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 43: goto st24;
 		case 58: goto st25;
@@ -556,14 +593,14 @@ case 24:
 		goto st24;
 	goto st0;
 tr7:
-#line 22 "http11_parser.rl"
+#line 34 "ext/http11/http11_parser.rl"
 	{MARK(mark, p); }
 	goto st25;
 st25:
 	if ( ++p == pe )
-		goto _out25;
+		goto _test_eof25;
 case 25:
-#line 567 "http11_parser.c"
+#line 604 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 32: goto tr8;
 		case 34: goto st0;
@@ -578,7 +615,7 @@ case 25:
 	goto st25;
 st26:
 	if ( ++p == pe )
-		goto _out26;
+		goto _test_eof26;
 case 26:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
@@ -591,7 +628,7 @@ case 26:
 	goto st0;
 st27:
 	if ( ++p == pe )
-		goto _out27;
+		goto _test_eof27;
 case 27:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
@@ -603,23 +640,23 @@ case 27:
 		goto st25;
 	goto st0;
 tr6:
-#line 22 "http11_parser.rl"
+#line 34 "ext/http11/http11_parser.rl"
 	{MARK(mark, p); }
 	goto st28;
 st28:
 	if ( ++p == pe )
-		goto _out28;
+		goto _test_eof28;
 case 28:
-#line 614 "http11_parser.c"
+#line 651 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
-		case 32: goto tr40;
+		case 32: goto tr42;
 		case 34: goto st0;
-		case 35: goto tr41;
+		case 35: goto tr43;
 		case 37: goto st29;
-		case 59: goto tr43;
+		case 59: goto tr45;
 		case 60: goto st0;
 		case 62: goto st0;
-		case 63: goto tr44;
+		case 63: goto tr46;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
@@ -627,7 +664,7 @@ case 28:
 	goto st28;
 st29:
 	if ( ++p == pe )
-		goto _out29;
+		goto _test_eof29;
 case 29:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
@@ -640,7 +677,7 @@ case 29:
 	goto st0;
 st30:
 	if ( ++p == pe )
-		goto _out30;
+		goto _test_eof30;
 case 30:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
@@ -651,8 +688,8 @@ case 30:
 	} else
 		goto st28;
 	goto st0;
-tr43:
-#line 60 "http11_parser.rl"
+tr45:
+#line 73 "ext/http11/http11_parser.rl"
 	{
     if(parser->request_path != NULL)
       parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
@@ -660,9 +697,9 @@ tr43:
 	goto st31;
 st31:
 	if ( ++p == pe )
-		goto _out31;
+		goto _test_eof31;
 case 31:
-#line 666 "http11_parser.c"
+#line 703 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
 		case 32: goto tr8;
 		case 34: goto st0;
@@ -678,7 +715,7 @@ case 31:
 	goto st31;
 st32:
 	if ( ++p == pe )
-		goto _out32;
+		goto _test_eof32;
 case 32:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
@@ -691,7 +728,7 @@ case 32:
 	goto st0;
 st33:
 	if ( ++p == pe )
-		goto _out33;
+		goto _test_eof33;
 case 33:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
@@ -702,8 +739,8 @@ case 33:
 	} else
 		goto st31;
 	goto st0;
-tr44:
-#line 60 "http11_parser.rl"
+tr46:
+#line 73 "ext/http11/http11_parser.rl"
 	{
     if(parser->request_path != NULL)
       parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
@@ -711,34 +748,34 @@ tr44:
 	goto st34;
 st34:
 	if ( ++p == pe )
-		goto _out34;
+		goto _test_eof34;
 case 34:
-#line 717 "http11_parser.c"
+#line 754 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
-		case 32: goto tr51;
+		case 32: goto tr53;
 		case 34: goto st0;
-		case 35: goto tr52;
-		case 37: goto tr53;
+		case 35: goto tr54;
+		case 37: goto tr55;
 		case 60: goto st0;
 		case 62: goto st0;
 		case 127: goto st0;
 	}
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
-	goto tr50;
-tr50:
-#line 49 "http11_parser.rl"
+	goto tr52;
+tr52:
+#line 62 "ext/http11/http11_parser.rl"
 	{MARK(query_start, p); }
 	goto st35;
 st35:
 	if ( ++p == pe )
-		goto _out35;
+		goto _test_eof35;
 case 35:
-#line 738 "http11_parser.c"
+#line 775 "ext/http11/http11_parser.c"
 	switch( (*p) ) {
-		case 32: goto tr55;
+		case 32: goto tr57;
 		case 34: goto st0;
-		case 35: goto tr56;
+		case 35: goto tr58;
 		case 37: goto st36;
 		case 60: goto st0;
 		case 62: goto st0;
@@ -747,15 +784,15 @@ case 35:
 	if ( 0 <= (*p) && (*p) <= 31 )
 		goto st0;
 	goto st35;
-tr53:
-#line 49 "http11_parser.rl"
+tr55:
+#line 62 "ext/http11/http11_parser.rl"
 	{MARK(query_start, p); }
 	goto st36;
 st36:
 	if ( ++p == pe )
-		goto _out36;
+		goto _test_eof36;
 case 36:
-#line 759 "http11_parser.c"
+#line 796 "ext/http11/http11_parser.c"
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
 			goto st37;
@@ -767,7 +804,7 @@ case 36:
 	goto st0;
 st37:
 	if ( ++p == pe )
-		goto _out37;
+		goto _test_eof37;
 case 37:
 	if ( (*p) < 65 ) {
 		if ( 48 <= (*p) && (*p) <= 57 )
@@ -780,7 +817,7 @@ case 37:
 	goto st0;
 st38:
 	if ( ++p == pe )
-		goto _out38;
+		goto _test_eof38;
 case 38:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -798,7 +835,7 @@ case 38:
 	goto st0;
 st39:
 	if ( ++p == pe )
-		goto _out39;
+		goto _test_eof39;
 case 39:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -816,7 +853,7 @@ case 39:
 	goto st0;
 st40:
 	if ( ++p == pe )
-		goto _out40;
+		goto _test_eof40;
 case 40:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -834,7 +871,7 @@ case 40:
 	goto st0;
 st41:
 	if ( ++p == pe )
-		goto _out41;
+		goto _test_eof41;
 case 41:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -852,7 +889,7 @@ case 41:
 	goto st0;
 st42:
 	if ( ++p == pe )
-		goto _out42;
+		goto _test_eof42;
 case 42:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -870,7 +907,7 @@ case 42:
 	goto st0;
 st43:
 	if ( ++p == pe )
-		goto _out43;
+		goto _test_eof43;
 case 43:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -888,7 +925,7 @@ case 43:
 	goto st0;
 st44:
 	if ( ++p == pe )
-		goto _out44;
+		goto _test_eof44;
 case 44:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -906,7 +943,7 @@ case 44:
 	goto st0;
 st45:
 	if ( ++p == pe )
-		goto _out45;
+		goto _test_eof45;
 case 45:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -924,7 +961,7 @@ case 45:
 	goto st0;
 st46:
 	if ( ++p == pe )
-		goto _out46;
+		goto _test_eof46;
 case 46:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -942,7 +979,7 @@ case 46:
 	goto st0;
 st47:
 	if ( ++p == pe )
-		goto _out47;
+		goto _test_eof47;
 case 47:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -960,7 +997,7 @@ case 47:
 	goto st0;
 st48:
 	if ( ++p == pe )
-		goto _out48;
+		goto _test_eof48;
 case 48:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -978,7 +1015,7 @@ case 48:
 	goto st0;
 st49:
 	if ( ++p == pe )
-		goto _out49;
+		goto _test_eof49;
 case 49:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -996,7 +1033,7 @@ case 49:
 	goto st0;
 st50:
 	if ( ++p == pe )
-		goto _out50;
+		goto _test_eof50;
 case 50:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -1014,7 +1051,7 @@ case 50:
 	goto st0;
 st51:
 	if ( ++p == pe )
-		goto _out51;
+		goto _test_eof51;
 case 51:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -1032,7 +1069,7 @@ case 51:
 	goto st0;
 st52:
 	if ( ++p == pe )
-		goto _out52;
+		goto _test_eof52;
 case 52:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -1050,7 +1087,7 @@ case 52:
 	goto st0;
 st53:
 	if ( ++p == pe )
-		goto _out53;
+		goto _test_eof53;
 case 53:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -1068,7 +1105,7 @@ case 53:
 	goto st0;
 st54:
 	if ( ++p == pe )
-		goto _out54;
+		goto _test_eof54;
 case 54:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -1086,7 +1123,7 @@ case 54:
 	goto st0;
 st55:
 	if ( ++p == pe )
-		goto _out55;
+		goto _test_eof55;
 case 55:
 	switch( (*p) ) {
 		case 32: goto tr2;
@@ -1104,75 +1141,76 @@ case 55:
 	goto st0;
 st56:
 	if ( ++p == pe )
-		goto _out56;
+		goto _test_eof56;
 case 56:
 	if ( (*p) == 32 )
 		goto tr2;
 	goto st0;
 	}
-	_out0: cs = 0; goto _out; 
-	_out2: cs = 2; goto _out; 
-	_out3: cs = 3; goto _out; 
-	_out4: cs = 4; goto _out; 
-	_out5: cs = 5; goto _out; 
-	_out6: cs = 6; goto _out; 
-	_out7: cs = 7; goto _out; 
-	_out8: cs = 8; goto _out; 
-	_out9: cs = 9; goto _out; 
-	_out10: cs = 10; goto _out; 
-	_out11: cs = 11; goto _out; 
-	_out12: cs = 12; goto _out; 
-	_out13: cs = 13; goto _out; 
-	_out14: cs = 14; goto _out; 
-	_out15: cs = 15; goto _out; 
-	_out16: cs = 16; goto _out; 
-	_out57: cs = 57; goto _out; 
-	_out17: cs = 17; goto _out; 
-	_out18: cs = 18; goto _out; 
-	_out19: cs = 19; goto _out; 
-	_out20: cs = 20; goto _out; 
-	_out21: cs = 21; goto _out; 
-	_out22: cs = 22; goto _out; 
-	_out23: cs = 23; goto _out; 
-	_out24: cs = 24; goto _out; 
-	_out25: cs = 25; goto _out; 
-	_out26: cs = 26; goto _out; 
-	_out27: cs = 27; goto _out; 
-	_out28: cs = 28; goto _out; 
-	_out29: cs = 29; goto _out; 
-	_out30: cs = 30; goto _out; 
-	_out31: cs = 31; goto _out; 
-	_out32: cs = 32; goto _out; 
-	_out33: cs = 33; goto _out; 
-	_out34: cs = 34; goto _out; 
-	_out35: cs = 35; goto _out; 
-	_out36: cs = 36; goto _out; 
-	_out37: cs = 37; goto _out; 
-	_out38: cs = 38; goto _out; 
-	_out39: cs = 39; goto _out; 
-	_out40: cs = 40; goto _out; 
-	_out41: cs = 41; goto _out; 
-	_out42: cs = 42; goto _out; 
-	_out43: cs = 43; goto _out; 
-	_out44: cs = 44; goto _out; 
-	_out45: cs = 45; goto _out; 
-	_out46: cs = 46; goto _out; 
-	_out47: cs = 47; goto _out; 
-	_out48: cs = 48; goto _out; 
-	_out49: cs = 49; goto _out; 
-	_out50: cs = 50; goto _out; 
-	_out51: cs = 51; goto _out; 
-	_out52: cs = 52; goto _out; 
-	_out53: cs = 53; goto _out; 
-	_out54: cs = 54; goto _out; 
-	_out55: cs = 55; goto _out; 
-	_out56: cs = 56; goto _out; 
+	_test_eof2: cs = 2; goto _test_eof; 
+	_test_eof3: cs = 3; goto _test_eof; 
+	_test_eof4: cs = 4; goto _test_eof; 
+	_test_eof5: cs = 5; goto _test_eof; 
+	_test_eof6: cs = 6; goto _test_eof; 
+	_test_eof7: cs = 7; goto _test_eof; 
+	_test_eof8: cs = 8; goto _test_eof; 
+	_test_eof9: cs = 9; goto _test_eof; 
+	_test_eof10: cs = 10; goto _test_eof; 
+	_test_eof11: cs = 11; goto _test_eof; 
+	_test_eof12: cs = 12; goto _test_eof; 
+	_test_eof13: cs = 13; goto _test_eof; 
+	_test_eof14: cs = 14; goto _test_eof; 
+	_test_eof15: cs = 15; goto _test_eof; 
+	_test_eof16: cs = 16; goto _test_eof; 
+	_test_eof57: cs = 57; goto _test_eof; 
+	_test_eof17: cs = 17; 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; 
+	_test_eof22: cs = 22; goto _test_eof; 
+	_test_eof23: cs = 23; goto _test_eof; 
+	_test_eof24: cs = 24; goto _test_eof; 
+	_test_eof25: cs = 25; goto _test_eof; 
+	_test_eof26: cs = 26; goto _test_eof; 
+	_test_eof27: cs = 27; goto _test_eof; 
+	_test_eof28: cs = 28; goto _test_eof; 
+	_test_eof29: cs = 29; goto _test_eof; 
+	_test_eof30: cs = 30; goto _test_eof; 
+	_test_eof31: cs = 31; goto _test_eof; 
+	_test_eof32: cs = 32; goto _test_eof; 
+	_test_eof33: cs = 33; goto _test_eof; 
+	_test_eof34: cs = 34; goto _test_eof; 
+	_test_eof35: cs = 35; goto _test_eof; 
+	_test_eof36: cs = 36; goto _test_eof; 
+	_test_eof37: cs = 37; goto _test_eof; 
+	_test_eof38: cs = 38; goto _test_eof; 
+	_test_eof39: cs = 39; goto _test_eof; 
+	_test_eof40: cs = 40; goto _test_eof; 
+	_test_eof41: cs = 41; goto _test_eof; 
+	_test_eof42: cs = 42; goto _test_eof; 
+	_test_eof43: cs = 43; goto _test_eof; 
+	_test_eof44: cs = 44; goto _test_eof; 
+	_test_eof45: cs = 45; goto _test_eof; 
+	_test_eof46: cs = 46; goto _test_eof; 
+	_test_eof47: cs = 47; goto _test_eof; 
+	_test_eof48: cs = 48; goto _test_eof; 
+	_test_eof49: cs = 49; goto _test_eof; 
+	_test_eof50: cs = 50; goto _test_eof; 
+	_test_eof51: cs = 51; goto _test_eof; 
+	_test_eof52: cs = 52; goto _test_eof; 
+	_test_eof53: cs = 53; goto _test_eof; 
+	_test_eof54: cs = 54; goto _test_eof; 
+	_test_eof55: cs = 55; goto _test_eof; 
+	_test_eof56: cs = 56; goto _test_eof; 
 
+	_test_eof: {}
 	_out: {}
 	}
-#line 109 "http11_parser.rl"
+#line 121 "ext/http11/http11_parser.rl"
 
-  parser->cs = cs;
+  if (!http_parser_has_error(parser))
+    parser->cs = cs;
   parser->nread += p - (buffer + off);
 
   assert(p <= pe && "buffer overflow after parsing execute");
@@ -1182,27 +1220,11 @@ case 56:
   assert(parser->field_len <= len && "field has length longer than whole buffer");
   assert(parser->field_start < len && "field starts after buffer end");
 
-  if(parser->body_start) {
-    /* final \r\n combo encountered so stop right here */
-    
-#line 1189 "http11_parser.c"
-#line 123 "http11_parser.rl"
-    parser->nread++;
-  }
-
   return(parser->nread);
 }
 
 int http_parser_finish(http_parser *parser)
 {
-  int cs = parser->cs;
-
-  
-#line 1202 "http11_parser.c"
-#line 134 "http11_parser.rl"
-
-  parser->cs = cs;
-
   if (http_parser_has_error(parser) ) {
     return -1;
   } else if (http_parser_is_finished(parser) ) {
@@ -1217,5 +1239,5 @@ int http_parser_has_error(http_parser *parser) {
 }
 
 int http_parser_is_finished(http_parser *parser) {
-  return parser->cs == http_parser_first_final;
+  return parser->cs >= http_parser_first_final;
 }