raptor 0.22.3 → 0.24.0

data/ext/raptor_http/raptor_http.c

@@ -6,15 +6,24 @@
 #include "ruby.h"
 #include "ruby/encoding.h"
 #include <assert.h>
-#include <string.h>
 #include <ctype.h>
+#include <stdint.h>
+#include <string.h>
 
 #define MAX_HEADER_LENGTH (112 * 1024)
 #define MAX_URI_LENGTH (12 * 1024)
 #define MAX_FIELD_NAME 256
 #define MAX_FIELD_VALUE (80 * 1024)
 
-typedef struct raptor_parser {
+// Bounds each chunk-size line and the terminal chunk/trailer section, including
+// CRLFs. Also limits cumulative nonterminal overhead beyond the payload size.
+#define MAX_CHUNK_OVERHEAD (16 * 1024)
+
+#define FLAG_CHUNKED  0x1
+#define FLAG_HAS_BODY 0x2
+#define FLAG_FINISHED 0x4
+
+typedef struct {
   int cs;
   size_t mark;
   size_t field_start;
@@ -22,10 +31,11 @@ typedef struct raptor_parser {
   size_t query_start;
   size_t nread;
   size_t body_start;
-  off_t content_len;
+  int64_t content_len;
   unsigned int flags;
   VALUE request;
-  VALUE body;
+  VALUE underscored_headers;
+  // Scratch space for the env key: "HTTP_" prefix + field name + NUL.
   char buf[MAX_FIELD_NAME + 6];
 } raptor_parser;
 
@@ -33,33 +43,29 @@ typedef struct raptor_parser {
 #define LEN(AT, P) ((P) - buffer - parser->AT)
 #define PTR_TO(F) (buffer + parser->F)
 
-#define FLAG_CHUNKED 0x1
-#define FLAG_HAS_BODY 0x2
-#define FLAG_FINISHED 0x4
-
-#define MAX_CHUNK_OVERHEAD (16 * 1024)
-
 static VALUE eHttpParserError;
 static VALUE global_request_method;
 static VALUE global_request_uri;
 static VALUE global_query_string;
 static VALUE global_server_protocol;
-static VALUE global_request_path;
+static VALUE global_path_info;
 static VALUE global_fragment;
 static ID id_complete;
 static ID id_incomplete;
 static ID id_malformed;
 static ID id_too_large;
 
-struct common_field {
+typedef struct {
   const char *name;
   size_t len;
   VALUE interned;
-};
+} common_field;
 
 #define FIELD(name) { name, sizeof(name) - 1, Qnil }
 
-static struct common_field common_fields[] = {
+// Env keys for frequently seen headers, interned once at load time so parsing
+// these headers does not need to look up the fstring table.
+static common_field common_fields[] = {
   FIELD("HTTP_HOST"),
   FIELD("HTTP_USER_AGENT"),
   FIELD("HTTP_CONNECTION"),
@@ -111,7 +117,7 @@ static struct common_field common_fields[] = {
 
 #define NUM_COMMON_FIELDS (sizeof(common_fields) / sizeof(common_fields[0]))
 
-static VALUE raptor_http_intern_field(const char *buf, size_t len) {
+static VALUE intern_field(const char *buf, size_t len) {
   for (size_t i = 0; i < NUM_COMMON_FIELDS; i++) {
     if (common_fields[i].len == len && memcmp(common_fields[i].name, buf, len) == 0) {
       return common_fields[i].interned;
@@ -120,13 +126,6 @@ static VALUE raptor_http_intern_field(const char *buf, size_t len) {
   return rb_enc_interned_str(buf, len, rb_utf8_encoding());
 }
 
-static inline void upcase_header_char(char *c) {
-  if (*c >= 'a' && *c <= 'z')
-    *c &= ~0x20;
-  else if (*c == '-')
-    *c = '_';
-}
-
 static int contains_chunked(const char *value, long len) {
   static const char chunked[] = "chunked";
   static const long chunked_len = sizeof(chunked) - 1;
@@ -142,11 +141,80 @@ static int contains_chunked(const char *value, long len) {
   return 0;
 }
 
+// Ruby checks for non-digit characters when it validates request framing.
+static int64_t parse_content_length(const char *value, long len) {
+  int64_t content_len = 0;
+  for (long i = 0; i < len && value[i] >= '0' && value[i] <= '9'; i++) {
+    int digit = value[i] - '0';
+    if (content_len > (INT64_MAX - digit) / 10)
+      rb_raise(eHttpParserError, "content length too large");
+    content_len = content_len * 10 + digit;
+  }
+  return content_len;
+}
+
+static void parse_header(raptor_parser *parser, const char *field, const char *value, size_t value_len) {
+  size_t field_len = parser->field_len;
+  if (field_len == 0 || field_len > MAX_FIELD_NAME)
+    rb_raise(eHttpParserError, "invalid field name length");
+  if (value_len > MAX_FIELD_VALUE)
+    rb_raise(eHttpParserError, "field value too long");
+
+  int underscored = 0;
+  char *normalized = parser->buf + 5;
+  for (size_t i = 0; i < field_len; i++) {
+    char c = field[i];
+    if (c == '_') underscored = 1;
+    normalized[i] = c == '-' ? '_' : (c >= 'a' && c <= 'z' ? c & ~0x20 : c);
+  }
+  int content_length = field_len == 14 && memcmp(normalized, "CONTENT_LENGTH", 14) == 0;
+  int content_type = field_len == 12 && memcmp(normalized, "CONTENT_TYPE", 12) == 0;
+  int transfer_encoding = field_len == 17 && memcmp(normalized, "TRANSFER_ENCODING", 17) == 0;
+  if (underscored && (content_length || transfer_encoding))
+    rb_raise(eHttpParserError, "invalid framing header name");
+
+  size_t key_len = field_len;
+  if (content_length || content_type) {
+    memmove(parser->buf, normalized, field_len);
+  } else {
+    memcpy(parser->buf, "HTTP_", 5);
+    key_len += 5;
+  }
+  VALUE key = intern_field(parser->buf, key_len);
+  VALUE existing = rb_hash_aref(parser->request, key);
+  int existing_underscored = !NIL_P(parser->underscored_headers) &&
+                            RTEST(rb_hash_aref(parser->underscored_headers, key));
+  // Canonical names win in either order; true duplicates still merge.
+  if (underscored) {
+    if (!NIL_P(existing) && !existing_underscored) return;
+    if (NIL_P(parser->underscored_headers)) parser->underscored_headers = rb_hash_new();
+    rb_hash_aset(parser->underscored_headers, key, Qtrue);
+  } else if (existing_underscored) {
+    existing = Qnil;
+    rb_hash_delete(parser->underscored_headers, key);
+  }
+
+  while (value_len > 0 && (value[value_len - 1] == ' ' || value[value_len - 1] == '\t'))
+    value_len--;
+  if (content_length) {
+    parser->content_len = parse_content_length(value, (long)value_len);
+    if (parser->content_len > 0) parser->flags |= FLAG_HAS_BODY;
+  } else if (transfer_encoding && contains_chunked(value, (long)value_len)) {
+    parser->flags |= FLAG_CHUNKED | FLAG_HAS_BODY;
+    parser->content_len = 0;
+  }
+
+  if (!NIL_P(existing)) {
+    rb_str_cat(existing, ", ", 2);
+    rb_str_cat(existing, value, (long)value_len);
+  } else {
+    rb_hash_aset(parser->request, key, rb_str_new(value, (long)value_len));
+  }
+}
+
 static const int raptor_parser_start = 1;
-static const int raptor_parser_first_final = 46;
-static const int raptor_parser_error = 0;
 
-size_t raptor_parser_execute(raptor_parser *parser, const char *buffer, size_t len) {
+static size_t raptor_parser_execute(raptor_parser *parser, const char *buffer, size_t len) {
   const char *p, *pe;
   int cs = parser->cs;
 
@@ -257,7 +325,7 @@ tr33:
 tr37:
 	{
     VALUE path = rb_str_new(PTR_TO(mark), LEN(mark,p));
-    rb_hash_aset(parser->request, global_request_path, path);
+    rb_hash_aset(parser->request, global_path_info, path);
   }
 	{
     if (LEN(mark, p) > MAX_URI_LENGTH)
@@ -370,122 +438,12 @@ tr18:
 tr26:
 	{ MARK(mark, p); }
 	{
-    if (parser->field_len == 0 || parser->field_len > MAX_FIELD_NAME)
-      rb_raise(eHttpParserError, "invalid field name length");
-
-    size_t value_len = LEN(mark, p);
-    if (value_len > MAX_FIELD_VALUE)
-      rb_raise(eHttpParserError, "field value too long");
-
-    const char *field_ptr = PTR_TO(field_start);
-
-    int needs_http_prefix = 1;
-    if (parser->field_len == 14 && memcmp(field_ptr, "CONTENT_LENGTH", 14) == 0)
-      needs_http_prefix = 0;
-    else if (parser->field_len == 12 && memcmp(field_ptr, "CONTENT_TYPE", 12) == 0)
-      needs_http_prefix = 0;
-
-    size_t key_len;
-    if (needs_http_prefix) {
-      memcpy(parser->buf, "HTTP_", 5);
-      memcpy(parser->buf + 5, field_ptr, parser->field_len);
-      key_len = 5 + parser->field_len;
-      parser->buf[key_len] = '\0';
-    } else {
-      memcpy(parser->buf, field_ptr, parser->field_len);
-      key_len = parser->field_len;
-      parser->buf[key_len] = '\0';
-    }
-
-    VALUE key = raptor_http_intern_field(parser->buf, key_len);
-    VALUE value = rb_str_new(PTR_TO(mark), value_len);
-
-    char *value_ptr = RSTRING_PTR(value);
-    long value_real_len = RSTRING_LEN(value);
-    while (value_real_len > 0 && (value_ptr[value_real_len - 1] == ' ' ||
-                                    value_ptr[value_real_len - 1] == '\t'))
-      value_real_len--;
-    rb_str_set_len(value, value_real_len);
-
-    if (!needs_http_prefix && parser->field_len == 14) {
-      parser->content_len = strtoul(RSTRING_PTR(value), NULL, 10);
-      if (parser->content_len > 0)
-        parser->flags |= FLAG_HAS_BODY;
-    } else if (needs_http_prefix && parser->field_len == 17 &&
-               memcmp(field_ptr, "TRANSFER_ENCODING", 17) == 0) {
-      if (contains_chunked(value_ptr, value_real_len)) {
-        parser->flags |= FLAG_CHUNKED | FLAG_HAS_BODY;
-        parser->content_len = 0;
-      }
-    }
-
-    VALUE existing = rb_hash_aref(parser->request, key);
-    if (!NIL_P(existing)) {
-      rb_str_cat2(existing, ", ");
-      rb_str_append(existing, value);
-    } else {
-      rb_hash_aset(parser->request, key, value);
-    }
+    parse_header(parser, PTR_TO(field_start), PTR_TO(mark), LEN(mark, p));
   }
 	goto st14;
 tr29:
 	{
-    if (parser->field_len == 0 || parser->field_len > MAX_FIELD_NAME)
-      rb_raise(eHttpParserError, "invalid field name length");
-
-    size_t value_len = LEN(mark, p);
-    if (value_len > MAX_FIELD_VALUE)
-      rb_raise(eHttpParserError, "field value too long");
-
-    const char *field_ptr = PTR_TO(field_start);
-
-    int needs_http_prefix = 1;
-    if (parser->field_len == 14 && memcmp(field_ptr, "CONTENT_LENGTH", 14) == 0)
-      needs_http_prefix = 0;
-    else if (parser->field_len == 12 && memcmp(field_ptr, "CONTENT_TYPE", 12) == 0)
-      needs_http_prefix = 0;
-
-    size_t key_len;
-    if (needs_http_prefix) {
-      memcpy(parser->buf, "HTTP_", 5);
-      memcpy(parser->buf + 5, field_ptr, parser->field_len);
-      key_len = 5 + parser->field_len;
-      parser->buf[key_len] = '\0';
-    } else {
-      memcpy(parser->buf, field_ptr, parser->field_len);
-      key_len = parser->field_len;
-      parser->buf[key_len] = '\0';
-    }
-
-    VALUE key = raptor_http_intern_field(parser->buf, key_len);
-    VALUE value = rb_str_new(PTR_TO(mark), value_len);
-
-    char *value_ptr = RSTRING_PTR(value);
-    long value_real_len = RSTRING_LEN(value);
-    while (value_real_len > 0 && (value_ptr[value_real_len - 1] == ' ' ||
-                                    value_ptr[value_real_len - 1] == '\t'))
-      value_real_len--;
-    rb_str_set_len(value, value_real_len);
-
-    if (!needs_http_prefix && parser->field_len == 14) {
-      parser->content_len = strtoul(RSTRING_PTR(value), NULL, 10);
-      if (parser->content_len > 0)
-        parser->flags |= FLAG_HAS_BODY;
-    } else if (needs_http_prefix && parser->field_len == 17 &&
-               memcmp(field_ptr, "TRANSFER_ENCODING", 17) == 0) {
-      if (contains_chunked(value_ptr, value_real_len)) {
-        parser->flags |= FLAG_CHUNKED | FLAG_HAS_BODY;
-        parser->content_len = 0;
-      }
-    }
-
-    VALUE existing = rb_hash_aref(parser->request, key);
-    if (!NIL_P(existing)) {
-      rb_str_cat2(existing, ", ");
-      rb_str_append(existing, value);
-    } else {
-      rb_hash_aset(parser->request, key, value);
-    }
+    parse_header(parser, PTR_TO(field_start), PTR_TO(mark), LEN(mark, p));
   }
 	goto st14;
 st14:
@@ -545,10 +503,8 @@ case 46:
 	goto st0;
 tr21:
 	{ MARK(field_start, p); }
-	{ upcase_header_char((char *)p); }
 	goto st17;
 tr23:
-	{ upcase_header_char((char *)p); }
 	goto st17;
 st17:
 	if ( ++p == pe )
@@ -591,6 +547,7 @@ st18:
 		goto _test_eof18;
 case 18:
 	switch( (*p) ) {
+		case 9: goto tr27;
 		case 13: goto tr26;
 		case 32: goto tr27;
 		case 127: goto st0;
@@ -629,7 +586,7 @@ tr9:
 tr38:
 	{
     VALUE path = rb_str_new(PTR_TO(mark), LEN(mark,p));
-    rb_hash_aset(parser->request, global_request_path, path);
+    rb_hash_aset(parser->request, global_path_info, path);
   }
 	{
     if (LEN(mark, p) > MAX_URI_LENGTH)
@@ -761,7 +718,7 @@ case 24:
 tr39:
 	{
     VALUE path = rb_str_new(PTR_TO(mark), LEN(mark,p));
-    rb_hash_aset(parser->request, global_request_path, path);
+    rb_hash_aset(parser->request, global_path_info, path);
   }
 	goto st25;
 st25:
@@ -1193,31 +1150,7 @@ done:
   return parser->nread;
 }
 
-int raptor_parser_finished(raptor_parser *parser) {
-  return (parser->flags & FLAG_FINISHED) != 0;
-}
-
-int raptor_parser_has_body(raptor_parser *parser) {
-  return (parser->flags & FLAG_HAS_BODY) != 0;
-}
-
-size_t raptor_parser_content_length(raptor_parser *parser) {
-  return parser->content_len;
-}
-
-int raptor_parser_is_chunked(raptor_parser *parser) {
-  return (parser->flags & FLAG_CHUNKED) != 0;
-}
-
-int raptor_parser_has_error(raptor_parser *parser) {
-  return parser->cs == raptor_parser_error;
-}
-
-int raptor_parser_is_finished(raptor_parser *parser) {
-  return parser->cs >= raptor_parser_first_final;
-}
-
-void raptor_parser_init(raptor_parser *parser) {
+static void raptor_parser_init(raptor_parser *parser) {
   parser->cs = raptor_parser_start;
   parser->mark = 0;
   parser->field_start = 0;
@@ -1228,19 +1161,13 @@ void raptor_parser_init(raptor_parser *parser) {
   parser->content_len = 0;
   parser->flags = 0;
   parser->request = Qnil;
-  parser->body = Qnil;
+  parser->underscored_headers = Qnil;
 }
 
-static VALUE cHttpParser;
-
 static void parser_mark(void *ptr) {
   raptor_parser *parser = ptr;
   rb_gc_mark(parser->request);
-  rb_gc_mark(parser->body);
-}
-
-static void parser_free(void *ptr) {
-  xfree(ptr);
+  rb_gc_mark(parser->underscored_headers);
 }
 
 static size_t parser_memsize(const void *ptr) {
@@ -1248,9 +1175,13 @@ static size_t parser_memsize(const void *ptr) {
 }
 
 static const rb_data_type_t parser_type = {
-  "raptor_http_parser",
-  { parser_mark, parser_free, parser_memsize },
-  0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+  .wrap_struct_name = "raptor_http_parser",
+  .function = {
+    .dmark = parser_mark,
+    .dfree = RUBY_TYPED_DEFAULT_FREE,
+    .dsize = parser_memsize,
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
 static VALUE parser_alloc(VALUE klass) {
@@ -1282,31 +1213,25 @@ static VALUE parser_execute(VALUE self, VALUE req_hash, VALUE buffer, VALUE star
 static VALUE parser_finished_p(VALUE self) {
   raptor_parser *parser;
   TypedData_Get_Struct(self, raptor_parser, &parser_type, parser);
-  return raptor_parser_finished(parser) ? Qtrue : Qfalse;
+  return (parser->flags & FLAG_FINISHED) ? Qtrue : Qfalse;
 }
 
 static VALUE parser_has_body_p(VALUE self) {
   raptor_parser *parser;
   TypedData_Get_Struct(self, raptor_parser, &parser_type, parser);
-  return raptor_parser_has_body(parser) ? Qtrue : Qfalse;
+  return (parser->flags & FLAG_HAS_BODY) ? Qtrue : Qfalse;
 }
 
 static VALUE parser_chunked_p(VALUE self) {
   raptor_parser *parser;
   TypedData_Get_Struct(self, raptor_parser, &parser_type, parser);
-  return raptor_parser_is_chunked(parser) ? Qtrue : Qfalse;
+  return (parser->flags & FLAG_CHUNKED) ? Qtrue : Qfalse;
 }
 
 static VALUE parser_content_length(VALUE self) {
   raptor_parser *parser;
   TypedData_Get_Struct(self, raptor_parser, &parser_type, parser);
-  return SIZET2NUM(raptor_parser_content_length(parser));
-}
-
-static VALUE parser_nread(VALUE self) {
-  raptor_parser *parser;
-  TypedData_Get_Struct(self, raptor_parser, &parser_type, parser);
-  return SIZET2NUM(parser->nread);
+  return LL2NUM(parser->content_len);
 }
 
 static VALUE parser_reset(VALUE self) {
@@ -1316,12 +1241,6 @@ static VALUE parser_reset(VALUE self) {
   return Qnil;
 }
 
-static VALUE parser_body(VALUE self) {
-  raptor_parser *parser;
-  TypedData_Get_Struct(self, raptor_parser, &parser_type, parser);
-  return parser->body;
-}
-
 static const char *find_crlf(const char *buf, size_t len) {
   if (len < 2) return NULL;
   const char *end = buf + len - 1;
@@ -1331,8 +1250,10 @@ static const char *find_crlf(const char *buf, size_t len) {
   return NULL;
 }
 
+// Decodes a chunked body into [decoded, state], appending the number of bytes
+// the body consumed when state is :complete so the caller can find any
+// pipelined request that follows it.
 static VALUE parser_decode_chunked(int argc, VALUE *argv, VALUE self) {
-  (void)self;
   VALUE buffer, max_size;
   rb_scan_args(argc, argv, "11", &buffer, &max_size);
   Check_Type(buffer, T_STRING);
@@ -1348,6 +1269,9 @@ static VALUE parser_decode_chunked(int argc, VALUE *argv, VALUE self) {
 
   while (offset < len) {
     const char *crlf = find_crlf(buf + offset, len - offset);
+    size_t line_bytes = crlf ? (size_t)(crlf - (buf + offset)) + 2 : len - offset;
+    if (line_bytes > MAX_CHUNK_OVERHEAD)
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
     if (!crlf) return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
 
     size_t line_len = (size_t)(crlf - (buf + offset));
@@ -1377,8 +1301,11 @@ static VALUE parser_decode_chunked(int argc, VALUE *argv, VALUE self) {
       while (1) {
         if (trailer_offset >= len) return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
         const char *tcrlf = find_crlf(buf + trailer_offset, len - trailer_offset);
+        size_t terminal_bytes = tcrlf ? (size_t)(tcrlf - (buf + offset)) + 2 : len - offset;
+        if (terminal_bytes > MAX_CHUNK_OVERHEAD)
+          return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
         if (!tcrlf) return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
-        if (tcrlf == buf + trailer_offset) return rb_ary_new_from_args(2, decoded, ID2SYM(id_complete));
+        if (tcrlf == buf + trailer_offset) return rb_ary_new_from_args(3, decoded, ID2SYM(id_complete), SIZET2NUM(trailer_offset + 2));
         trailer_offset = (size_t)(tcrlf - buf) + 2;
       }
     }
@@ -1398,12 +1325,23 @@ static VALUE parser_decode_chunked(int argc, VALUE *argv, VALUE self) {
     size_t bytes_to_copy = (size_t)chunk_size < available ? (size_t)chunk_size : available;
     rb_str_cat(decoded, buf + data_offset, (long)bytes_to_copy);
 
+    if (available <= (size_t)chunk_size)
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
+    if (buf[data_offset + (size_t)chunk_size] != '\r')
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+    if (available == (size_t)chunk_size + 1)
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
+    if (buf[data_offset + (size_t)chunk_size + 1] != '\n')
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+
     offset = data_offset + (size_t)chunk_size + 2;
   }
 
   return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
 }
 
+// One bit per byte value. Header names reject C0 controls, space, DEL and
+// separators; header values reject C0 controls other than horizontal tab.
 static uint8_t illegal_header_key_bitmap[32];
 static uint8_t illegal_header_value_bitmap[32];
 
@@ -1411,6 +1349,16 @@ static void bitmap_set(uint8_t *bitmap, unsigned char byte) {
   bitmap[byte >> 3] |= (uint8_t)(1u << (byte & 7));
 }
 
+static void init_illegal_header_bitmaps(void) {
+  for (int byte = 0x00; byte <= 0x20; byte++) bitmap_set(illegal_header_key_bitmap, (unsigned char)byte);
+  const char *key_specials = "()<>@,;:\\\"/[]?={}";
+  for (const char *p = key_specials; *p; p++) bitmap_set(illegal_header_key_bitmap, (unsigned char)*p);
+  bitmap_set(illegal_header_key_bitmap, 0x7F);
+
+  for (int byte = 0x00; byte <= 0x08; byte++) bitmap_set(illegal_header_value_bitmap, (unsigned char)byte);
+  for (int byte = 0x0A; byte <= 0x1F; byte++) bitmap_set(illegal_header_value_bitmap, (unsigned char)byte);
+}
+
 static int contains_illegal_byte(const uint8_t *bitmap, const char *str, size_t len) {
   for (size_t i = 0; i < len; i++) {
     unsigned char byte = (unsigned char)str[i];
@@ -1420,13 +1368,11 @@ static int contains_illegal_byte(const uint8_t *bitmap, const char *str, size_t
 }
 
 static VALUE parser_illegal_header_key_p(VALUE self, VALUE key) {
-  (void)self;
   Check_Type(key, T_STRING);
   return contains_illegal_byte(illegal_header_key_bitmap, RSTRING_PTR(key), (size_t)RSTRING_LEN(key)) ? Qtrue : Qfalse;
 }
 
 static VALUE parser_illegal_header_value_p(VALUE self, VALUE value) {
-  (void)self;
   Check_Type(value, T_STRING);
   return contains_illegal_byte(illegal_header_value_bitmap, RSTRING_PTR(value), (size_t)RSTRING_LEN(value)) ? Qtrue : Qfalse;
 }
@@ -1442,7 +1388,7 @@ static void emit_header_line(VALUE buffer, const char *name, long name_len,
 }
 
 static void emit_header(VALUE buffer, const char *name, long name_len, VALUE value) {
-  VALUE str = RB_TYPE_P(value, T_STRING) ? value : rb_funcall(value, rb_intern("to_s"), 0);
+  VALUE str = rb_obj_as_string(value);
   const char *ptr = RSTRING_PTR(str);
   long len = RSTRING_LEN(str);
   if (len == 0) return;
@@ -1459,13 +1405,10 @@ static void emit_header(VALUE buffer, const char *name, long name_len, VALUE val
       line_start = i + 1;
     }
   }
-  if (line_start < len) {
-    emit_header_line(buffer, name, name_len, ptr + line_start, len - line_start);
-  }
+  if (line_start < len) emit_header_line(buffer, name, name_len, ptr + line_start, len - line_start);
 }
 
-static int format_header_iter(VALUE key, VALUE value, VALUE data) {
-  VALUE buffer = (VALUE)data;
+static int format_header_iter(VALUE key, VALUE value, VALUE buffer) {
   if (!RB_TYPE_P(key, T_STRING)) return ST_CONTINUE;
   const char *name = RSTRING_PTR(key);
   long name_len = RSTRING_LEN(key);
@@ -1483,7 +1426,6 @@ static int format_header_iter(VALUE key, VALUE value, VALUE data) {
 }
 
 static VALUE parser_format_headers(VALUE self, VALUE buffer, VALUE headers) {
-  (void)self;
   Check_Type(buffer, T_STRING);
   Check_Type(headers, T_HASH);
   rb_hash_foreach(headers, format_header_iter, buffer);
@@ -1491,7 +1433,6 @@ static VALUE parser_format_headers(VALUE self, VALUE buffer, VALUE headers) {
 }
 
 static VALUE parser_chunked_encode(VALUE self, VALUE buffer, VALUE chunk) {
-  (void)self;
   Check_Type(buffer, T_STRING);
   Check_Type(chunk, T_STRING);
   long chunk_len = RSTRING_LEN(chunk);
@@ -1506,36 +1447,27 @@ static VALUE parser_chunked_encode(VALUE self, VALUE buffer, VALUE chunk) {
   return buffer;
 }
 
-static void init_illegal_header_bitmaps(void) {
-  for (int byte = 0x00; byte <= 0x20; byte++) bitmap_set(illegal_header_key_bitmap, (unsigned char)byte);
-  const char *key_specials = "()<>@,;:\\\"/[]?={}";
-  for (const char *p = key_specials; *p; p++) bitmap_set(illegal_header_key_bitmap, (unsigned char)*p);
-  bitmap_set(illegal_header_key_bitmap, 0x7F);
-
-  for (int byte = 0x00; byte <= 0x08; byte++) bitmap_set(illegal_header_value_bitmap, (unsigned char)byte);
-  for (int byte = 0x0A; byte <= 0x1F; byte++) bitmap_set(illegal_header_value_bitmap, (unsigned char)byte);
-}
-
 RUBY_FUNC_EXPORTED void Init_raptor_http(void) {
   rb_ext_ractor_safe(true);
 
-  VALUE mRaptor = rb_define_module("Raptor");
-  cHttpParser = rb_define_class_under(mRaptor, "HttpParser", rb_cObject);
-  eHttpParserError = rb_define_class_under(mRaptor, "HttpParserError", rb_eStandardError);
-
   rb_global_variable(&global_request_method);
   rb_global_variable(&global_request_uri);
   rb_global_variable(&global_query_string);
   rb_global_variable(&global_server_protocol);
-  rb_global_variable(&global_request_path);
+  rb_global_variable(&global_path_info);
   rb_global_variable(&global_fragment);
 
-  global_request_method = rb_str_new2("REQUEST_METHOD");
-  global_request_uri = rb_str_new2("REQUEST_URI");
-  global_query_string = rb_str_new2("QUERY_STRING");
-  global_server_protocol = rb_str_new2("SERVER_PROTOCOL");
-  global_request_path = rb_str_new2("PATH_INFO");
-  global_fragment = rb_str_new2("FRAGMENT");
+  global_request_method = rb_str_new_lit("REQUEST_METHOD");
+  global_request_uri = rb_str_new_lit("REQUEST_URI");
+  global_query_string = rb_str_new_lit("QUERY_STRING");
+  global_server_protocol = rb_str_new_lit("SERVER_PROTOCOL");
+  global_path_info = rb_str_new_lit("PATH_INFO");
+  global_fragment = rb_str_new_lit("FRAGMENT");
+
+  for (size_t i = 0; i < NUM_COMMON_FIELDS; i++) {
+    rb_global_variable(&common_fields[i].interned);
+    common_fields[i].interned = rb_enc_interned_str(common_fields[i].name, common_fields[i].len, rb_utf8_encoding());
+  }
 
   id_complete = rb_intern("complete");
   id_incomplete = rb_intern("incomplete");
@@ -1544,10 +1476,11 @@ RUBY_FUNC_EXPORTED void Init_raptor_http(void) {
 
   init_illegal_header_bitmaps();
 
-  for (size_t i = 0; i < NUM_COMMON_FIELDS; i++) {
-    common_fields[i].interned = rb_enc_interned_str(common_fields[i].name, common_fields[i].len, rb_utf8_encoding());
-    rb_global_variable(&common_fields[i].interned);
-  }
+  VALUE mRaptor = rb_define_module("Raptor");
+  VALUE cHttpParser = rb_define_class_under(mRaptor, "HttpParser", rb_cObject);
+  eHttpParserError = rb_define_class_under(mRaptor, "HttpParserError", rb_eStandardError);
+
+  rb_define_const(cHttpParser, "MAX_CHUNK_OVERHEAD", INT2FIX(MAX_CHUNK_OVERHEAD));
 
   rb_define_alloc_func(cHttpParser, parser_alloc);
   rb_define_method(cHttpParser, "execute", parser_execute, 3);
@@ -1555,13 +1488,11 @@ RUBY_FUNC_EXPORTED void Init_raptor_http(void) {
   rb_define_method(cHttpParser, "has_body?", parser_has_body_p, 0);
   rb_define_method(cHttpParser, "chunked?", parser_chunked_p, 0);
   rb_define_method(cHttpParser, "content_length", parser_content_length, 0);
-  rb_define_method(cHttpParser, "nread", parser_nread, 0);
   rb_define_method(cHttpParser, "reset", parser_reset, 0);
-  rb_define_method(cHttpParser, "body", parser_body, 0);
+
   rb_define_singleton_method(cHttpParser, "decode_chunked", parser_decode_chunked, -1);
   rb_define_singleton_method(cHttpParser, "illegal_header_key?", parser_illegal_header_key_p, 1);
   rb_define_singleton_method(cHttpParser, "illegal_header_value?", parser_illegal_header_value_p, 1);
   rb_define_singleton_method(cHttpParser, "format_headers", parser_format_headers, 2);
   rb_define_singleton_method(cHttpParser, "chunked_encode", parser_chunked_encode, 2);
-  rb_define_const(cHttpParser, "MAX_CHUNK_OVERHEAD", INT2FIX(MAX_CHUNK_OVERHEAD));
 }