Backport Eric's changes to the http parser from trunk (Eric Wong).

Apply fix for Ragel 6 (Eric Wong, Ry Dahl).

Two tests fail with the new parser (1 failed with the old parser). Needs investigation.

Close #12 (mongrel_rails send_signal leaves a filehandle open until gc).
Close #14 (mongrel_rails command line option --num-procs does not change the max number of procs).
Close #15 (mongrel squashes helpful exception in register method).
Close #16, XXX needs audit! (CGIWrapper "options" attr_reader has no corresponding @options variable).
Close #20 (Mongrel doesn't erase temporary files during it's operation on windows).
Close #19, XXX needs audit! (HttpResponse#reset does not properly reset HeaderOut).
Close #22 (gem_plugin should load gems from Gem.path not Gem.dir).
Close #23 (mongrel_cluster's mongrel_rails configuration option isn't fully respected).

If I had git, being offline wouldn't have resulted in one massive commit.



git-svn-id: svn+ssh://rubyforge.org/var/svn/mongrel/branches/stable_1-2@995 19e92222-5c0b-0410-8929-a290d50e31e9

6 files changed, 420 insertions, 271 deletions

diff --git a/ext/http11/ext_help.h b/ext/http11/ext_help.h
index 8b4d754..08c0e1e 100644
--- a/ext/http11/ext_help.h
+++ b/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__)
diff --git a/ext/http11/http11.c b/ext/http11/http11.c
index 2982467..a228019 100644
--- a/ext/http11/http11.c
+++ b/ext/http11/http11.c
@@ -7,7 +7,13 @@
 #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
 
 static VALUE mMongrel;
 static VALUE cHttpParser;
@@ -15,8 +21,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 +66,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 +187,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 +294,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 +420,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 +491,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 +508,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.2.0"); /* XXX Why is this defined here? */
+  DEF_GLOBAL(mongrel_version, "Mongrel 1.2"); /* XXX Why is this defined here? */
   DEF_GLOBAL(server_software, "SERVER_SOFTWARE");
   DEF_GLOBAL(port_80, "80");
 
@@ -399,4 +523,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();
 }
diff --git a/ext/http11/http11_parser.c b/ext/http11/http11_parser.c
index 1712d29..c2143de 100644
--- a/ext/http11/http11_parser.c
+++ b/ext/http11/http11_parser.c
@@ -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 "http11_parser.rl"
 
 
 /** Data **/
 
-#line 25 "http11_parser.c"
+#line 37 "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 "http11_parser.rl"
 
 int http_parser_init(http_parser *parser)  {
   int cs = 0;
   
-#line 37 "http11_parser.c"
+#line 49 "http11_parser.c"
         {
         cs = http_parser_start;
         }
-#line 82 "http11_parser.rl"
+#line 95 "http11_parser.rl"
   parser->cs = cs;
   parser->body_start = 0;
   parser->content_len = 0;
@@ -60,15 +72,15 @@ 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 81 "http11_parser.c"
         {
         if ( p == pe )
-                goto _out;
+                goto _test_eof;
         switch ( cs )
         {
 case 1:
@@ -86,16 +98,17 @@ case 1:
                 goto tr0;
         goto st0;
 st0:
-        goto _out0;
+cs = 0;
+        goto _out;
 tr0:
-#line 22 "http11_parser.rl"
+#line 34 "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 112 "http11_parser.c"
         switch( (*p) ) {
                 case 32: goto tr2;
                 case 36: goto st38;
@@ -111,7 +124,7 @@ case 2:
                 goto st38;
         goto st0;
 tr2:
-#line 36 "http11_parser.rl"
+#line 49 "http11_parser.rl"
         { 
     if(parser->request_method != NULL) 
       parser->request_method(parser->data, PTR_TO(mark), LEN(mark, p));
@@ -119,9 +132,9 @@ tr2:
         goto st3;
 st3:
         if ( ++p == pe )
-                goto _out3;
+                goto _test_eof3;
 case 3:
-#line 125 "http11_parser.c"
+#line 138 "http11_parser.c"
         switch( (*p) ) {
                 case 42: goto tr4;
                 case 43: goto tr5;
@@ -138,66 +151,75 @@ case 3:
                 goto tr5;
         goto st0;
 tr4:
-#line 22 "http11_parser.rl"
+#line 34 "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 162 "http11_parser.c"
         switch( (*p) ) {
                 case 32: goto tr8;
                 case 35: goto tr9;
         }
         goto st0;
 tr8:
-#line 40 "http11_parser.rl"
+#line 53 "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 "http11_parser.rl"
+        {MARK(mark, p); }
+#line 57 "http11_parser.rl"
+        { 
+    if(parser->fragment != NULL)
+      parser->fragment(parser->data, PTR_TO(mark), LEN(mark, p));
+  }
+        goto st5;
+tr34:
+#line 57 "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"
+tr42:
+#line 73 "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 "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 "http11_parser.rl"
         {MARK(query_start, p); }
-#line 50 "http11_parser.rl"
+#line 63 "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 "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 "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 "http11_parser.rl"
         { 
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
@@ -205,55 +227,55 @@ tr55:
         goto st5;
 st5:
         if ( ++p == pe )
-                goto _out5;
+                goto _test_eof5;
 case 5:
-#line 211 "http11_parser.c"
+#line 233 "http11_parser.c"
         if ( (*p) == 72 )
                 goto tr10;
         goto st0;
 tr10:
-#line 22 "http11_parser.rl"
+#line 34 "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 245 "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 +284,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,14 +299,24 @@ case 13:
                 goto st13;
         goto st0;
 tr18:
-#line 55 "http11_parser.rl"
+#line 68 "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 "http11_parser.rl"
+        { MARK(mark, p); }
+#line 44 "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 "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 +325,15 @@ tr26:
         goto st14;
 st14:
         if ( ++p == pe )
-                goto _out14;
+                goto _test_eof14;
 case 14:
-#line 299 "http11_parser.c"
+#line 331 "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 +361,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 "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 383 "http11_parser.c"
         goto st0;
 tr21:
-#line 25 "http11_parser.rl"
+#line 37 "http11_parser.rl"
         { MARK(field_start, p); }
+#line 38 "http11_parser.rl"
+        { snake_upcase_char((char *)p); }
+        goto st17;
+tr23:
+#line 38 "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 399 "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 "http11_parser.rl"
         { 
     parser->field_len = LEN(field_start, p);
   }
         goto st18;
 tr27:
-#line 30 "http11_parser.rl"
+#line 43 "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 438 "http11_parser.c"
         switch( (*p) ) {
                 case 13: goto tr26;
                 case 32: goto tr27;
         }
         goto tr25;
 tr25:
-#line 30 "http11_parser.rl"
+#line 43 "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 452 "http11_parser.c"
         if ( (*p) == 13 )
-                goto tr26;
+                goto tr29;
         goto st19;
 tr9:
-#line 40 "http11_parser.rl"
+#line 53 "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 "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 "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 "http11_parser.rl"
         {MARK(query_start, p); }
-#line 50 "http11_parser.rl"
+#line 63 "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 "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 "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 "http11_parser.rl"
         { 
     if(parser->request_uri != NULL)
       parser->request_uri(parser->data, PTR_TO(mark), LEN(mark, p));
@@ -461,12 +499,12 @@ tr56:
         goto st20;
 st20:
         if ( ++p == pe )
-                goto _out20;
+                goto _test_eof20;
 case 20:
-#line 467 "http11_parser.c"
+#line 505 "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 +514,18 @@ case 20:
                         goto st0;
         } else if ( (*p) >= 0 )
                 goto st0;
-        goto tr29;
-tr29:
-#line 22 "http11_parser.rl"
+        goto tr30;
+tr30:
+#line 34 "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 527 "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 +537,15 @@ case 21:
         } else if ( (*p) >= 0 )
                 goto st0;
         goto st21;
-tr31:
-#line 22 "http11_parser.rl"
+tr32:
+#line 34 "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 549 "http11_parser.c"
         if ( (*p) < 65 ) {
                 if ( 48 <= (*p) && (*p) <= 57 )
                         goto st23;
@@ -519,7 +557,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 +569,14 @@ case 23:
                 goto st21;
         goto st0;
 tr5:
-#line 22 "http11_parser.rl"
+#line 34 "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 580 "http11_parser.c"
         switch( (*p) ) {
                 case 43: goto st24;
                 case 58: goto st25;
@@ -556,14 +594,14 @@ case 24:
                 goto st24;
         goto st0;
 tr7:
-#line 22 "http11_parser.rl"
+#line 34 "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 605 "http11_parser.c"
         switch( (*p) ) {
                 case 32: goto tr8;
                 case 34: goto st0;
@@ -578,7 +616,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 +629,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 +641,23 @@ case 27:
                 goto st25;
         goto st0;
 tr6:
-#line 22 "http11_parser.rl"
+#line 34 "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 652 "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 +665,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 +678,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 +689,8 @@ case 30:
         } else
                 goto st28;
         goto st0;
-tr43:
-#line 60 "http11_parser.rl"
+tr45:
+#line 73 "http11_parser.rl"
         {
     if(parser->request_path != NULL)
       parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
@@ -660,9 +698,9 @@ tr43:
         goto st31;
 st31:
         if ( ++p == pe )
-                goto _out31;
+                goto _test_eof31;
 case 31:
-#line 666 "http11_parser.c"
+#line 704 "http11_parser.c"
         switch( (*p) ) {
                 case 32: goto tr8;
                 case 34: goto st0;
@@ -678,7 +716,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 +729,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 +740,8 @@ case 33:
         } else
                 goto st31;
         goto st0;
-tr44:
-#line 60 "http11_parser.rl"
+tr46:
+#line 73 "http11_parser.rl"
         {
     if(parser->request_path != NULL)
       parser->request_path(parser->data, PTR_TO(mark), LEN(mark,p));
@@ -711,34 +749,34 @@ tr44:
         goto st34;
 st34:
         if ( ++p == pe )
-                goto _out34;
+                goto _test_eof34;
 case 34:
-#line 717 "http11_parser.c"
+#line 755 "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 "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 776 "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 +785,15 @@ case 35:
         if ( 0 <= (*p) && (*p) <= 31 )
                 goto st0;
         goto st35;
-tr53:
-#line 49 "http11_parser.rl"
+tr55:
+#line 62 "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 797 "http11_parser.c"
         if ( (*p) < 65 ) {
                 if ( 48 <= (*p) && (*p) <= 57 )
                         goto st37;
@@ -767,7 +805,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 +818,7 @@ case 37:
         goto st0;
 st38:
         if ( ++p == pe )
-                goto _out38;
+                goto _test_eof38;
 case 38:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -798,7 +836,7 @@ case 38:
         goto st0;
 st39:
         if ( ++p == pe )
-                goto _out39;
+                goto _test_eof39;
 case 39:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -816,7 +854,7 @@ case 39:
         goto st0;
 st40:
         if ( ++p == pe )
-                goto _out40;
+                goto _test_eof40;
 case 40:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -834,7 +872,7 @@ case 40:
         goto st0;
 st41:
         if ( ++p == pe )
-                goto _out41;
+                goto _test_eof41;
 case 41:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -852,7 +890,7 @@ case 41:
         goto st0;
 st42:
         if ( ++p == pe )
-                goto _out42;
+                goto _test_eof42;
 case 42:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -870,7 +908,7 @@ case 42:
         goto st0;
 st43:
         if ( ++p == pe )
-                goto _out43;
+                goto _test_eof43;
 case 43:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -888,7 +926,7 @@ case 43:
         goto st0;
 st44:
         if ( ++p == pe )
-                goto _out44;
+                goto _test_eof44;
 case 44:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -906,7 +944,7 @@ case 44:
         goto st0;
 st45:
         if ( ++p == pe )
-                goto _out45;
+                goto _test_eof45;
 case 45:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -924,7 +962,7 @@ case 45:
         goto st0;
 st46:
         if ( ++p == pe )
-                goto _out46;
+                goto _test_eof46;
 case 46:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -942,7 +980,7 @@ case 46:
         goto st0;
 st47:
         if ( ++p == pe )
-                goto _out47;
+                goto _test_eof47;
 case 47:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -960,7 +998,7 @@ case 47:
         goto st0;
 st48:
         if ( ++p == pe )
-                goto _out48;
+                goto _test_eof48;
 case 48:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -978,7 +1016,7 @@ case 48:
         goto st0;
 st49:
         if ( ++p == pe )
-                goto _out49;
+                goto _test_eof49;
 case 49:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -996,7 +1034,7 @@ case 49:
         goto st0;
 st50:
         if ( ++p == pe )
-                goto _out50;
+                goto _test_eof50;
 case 50:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -1014,7 +1052,7 @@ case 50:
         goto st0;
 st51:
         if ( ++p == pe )
-                goto _out51;
+                goto _test_eof51;
 case 51:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -1032,7 +1070,7 @@ case 51:
         goto st0;
 st52:
         if ( ++p == pe )
-                goto _out52;
+                goto _test_eof52;
 case 52:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -1050,7 +1088,7 @@ case 52:
         goto st0;
 st53:
         if ( ++p == pe )
-                goto _out53;
+                goto _test_eof53;
 case 53:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -1068,7 +1106,7 @@ case 53:
         goto st0;
 st54:
         if ( ++p == pe )
-                goto _out54;
+                goto _test_eof54;
 case 54:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -1086,7 +1124,7 @@ case 54:
         goto st0;
 st55:
         if ( ++p == pe )
-                goto _out55;
+                goto _test_eof55;
 case 55:
         switch( (*p) ) {
                 case 32: goto tr2;
@@ -1104,73 +1142,73 @@ 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 122 "http11_parser.rl"
 
   parser->cs = cs;
   parser->nread += p - (buffer + off);
@@ -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;
 }
diff --git a/ext/http11/http11_parser.java.rl b/ext/http11/http11_parser.java.rl
index 71f8d3c..c9be22e 100644
--- a/ext/http11/http11_parser.java.rl
+++ b/ext/http11/http11_parser.java.rl
@@ -13,6 +13,7 @@ public class Http11Parser {
   action mark {parser.mark = fpc; }
 
   action start_field { parser.field_start = fpc; }
+  action snake_upcase_field { /* FIXME stub */ }
   action write_field { 
     parser.field_len = fpc-parser.field_start;
   }
diff --git a/ext/http11/http11_parser.rl b/ext/http11/http11_parser.rl
index fffe57a..5e551a3 100644
--- a/ext/http11/http11_parser.rl
+++ b/ext/http11/http11_parser.rl
@@ -9,6 +9,18 @@
 #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)
@@ -23,6 +35,7 @@
 
 
   action start_field { MARK(field_start, fpc); }
+  action snake_upcase_field { snake_upcase_char((char *)fpc); }
   action write_field { 
     parser->field_len = LEN(field_start, fpc);
   }
@@ -101,10 +114,9 @@ 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");
 
-
   %% write exec;
 
   parser->cs = cs;
@@ -117,23 +129,11 @@ size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len,
   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 */
-    %%write eof;
-    parser->nread++;
-  }
-
   return(parser->nread);
 }
 
 int http_parser_finish(http_parser *parser)
 {
-  int cs = parser->cs;
-
-  %%write eof;
-
-  parser->cs = cs;
-
   if (http_parser_has_error(parser) ) {
     return -1;
   } else if (http_parser_is_finished(parser) ) {
@@ -148,5 +148,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;
 }
diff --git a/ext/http11/http11_parser_common.rl b/ext/http11/http11_parser_common.rl
index a70d4da..53c805f 100644
--- a/ext/http11/http11_parser_common.rl
+++ b/ext/http11/http11_parser_common.rl
@@ -41,7 +41,7 @@
   HTTP_Version = ( "HTTP/" http_number ) >mark %http_version ;
   Request_Line = ( Method " " Request_URI ("#" Fragment){0,1} " " HTTP_Version CRLF ) ;
 
-  field_name = ( token -- ":" )+ >start_field %write_field;
+  field_name = ( token -- ":" )+ >start_field $snake_upcase_field %write_field;
 
   field_value = any* >start_value %write_value;