puma 7.1.0-java → 8.0.0-java

data/ext/puma_http11/org/jruby/puma/Http11Parser.java

@@ -4,6 +4,7 @@ package org.jruby.puma;
 
 import org.jruby.Ruby;
 import org.jruby.RubyHash;
+import org.jruby.RubyString;
 import org.jruby.util.ByteList;
 
 public class Http11Parser {
@@ -11,12 +12,12 @@ public class Http11Parser {
 /** Machine **/
 
 
-// line 58 "ext/puma_http11/http11_parser.java.rl"
+// line 59 "ext/puma_http11/http11_parser.java.rl"
 
 
 /** Data **/
 
-// line 20 "ext/puma_http11/org/jruby/puma/Http11Parser.java"
+// line 21 "ext/puma_http11/org/jruby/puma/Http11Parser.java"
 private static byte[] init__puma_parser_actions_0()
 {
 	return new byte [] {
@@ -185,66 +186,51 @@ static final int puma_parser_first_final = 46;
 static final int puma_parser_error = 0;
 
 
-// line 62 "ext/puma_http11/http11_parser.java.rl"
+// line 63 "ext/puma_http11/http11_parser.java.rl"
 
-   public static interface ElementCB {
-     public void call(Ruby runtime, RubyHash data, ByteList buffer, int at, int length);
-   }
-
-   public static interface FieldCB {
-     public void call(Ruby runtime, RubyHash data, ByteList buffer, int field, int flen, int value, int vlen);
-   }
-
-   public static class HttpParser {
-      int cs;
-      int body_start;
-      int content_len;
-      int nread;
-      int mark;
-      int field_start;
-      int field_len;
-      int query_start;
+   int cs;
+   int body_start;
+   int nread;
+   int mark;
+   int field_start;
+   int field_len;
+   int query_start;
 
-      RubyHash data;
-      ByteList buffer;
+   RubyHash data;
+   byte[] buffer;
 
-      public void init() {
-          cs = 0;
+   public void init() {
 
-          
-// line 216 "ext/puma_http11/org/jruby/puma/Http11Parser.java"
+       
+// line 206 "ext/puma_http11/org/jruby/puma/Http11Parser.java"
 	{
 	cs = puma_parser_start;
 	}
 
-// line 88 "ext/puma_http11/http11_parser.java.rl"
+// line 78 "ext/puma_http11/http11_parser.java.rl"
 
-          body_start = 0;
-          content_len = 0;
-          mark = 0;
-          nread = 0;
-          field_len = 0;
-          field_start = 0;
-      }
+       body_start = 0;
+       mark = 0;
+       nread = 0;
+       field_len = 0;
+       field_start = 0;
    }
 
-   public final HttpParser parser = new HttpParser();
-
    public int execute(Ruby runtime, Http11 http, ByteList buffer, int off) {
      int p, pe;
-     int cs = parser.cs;
+     int cs = this.cs;
      int len = buffer.length();
+     int beg = buffer.begin();
+     RubyString[] envStrings = http.envStrings;
      assert off<=len : "offset past end of buffer";
 
-     p = off;
-     pe = len;
-     // get a copy of the bytes, since it may not start at 0
-     // FIXME: figure out how to just use the bytes in-place
-     byte[] data = buffer.bytes();
-     parser.buffer = buffer;
+     p = beg + off;
+     pe = beg + len;
+     byte[] data = buffer.unsafeBytes();
+     this.buffer = data;
 
      
-// line 248 "ext/puma_http11/org/jruby/puma/Http11Parser.java"
+// line 234 "ext/puma_http11/org/jruby/puma/Http11Parser.java"
 	{
 	int _klen;
 	int _trans = 0;
@@ -325,82 +311,82 @@ case 1:
 			switch ( _puma_parser_actions[_acts++] )
 			{
 	case 0:
-// line 15 "ext/puma_http11/http11_parser.java.rl"
-	{parser.mark = p; }
+// line 16 "ext/puma_http11/http11_parser.java.rl"
+	{this.mark = p; }
 	break;
 	case 1:
-// line 17 "ext/puma_http11/http11_parser.java.rl"
-	{ parser.field_start = p; }
+// line 18 "ext/puma_http11/http11_parser.java.rl"
+	{ this.field_start = p; }
 	break;
 	case 2:
-// line 18 "ext/puma_http11/http11_parser.java.rl"
-	{ /* FIXME stub */ }
+// line 19 "ext/puma_http11/http11_parser.java.rl"
+	{ /* done lazily as needed */ }
 	break;
 	case 3:
-// line 19 "ext/puma_http11/http11_parser.java.rl"
+// line 20 "ext/puma_http11/http11_parser.java.rl"
 	{ 
-    parser.field_len = p-parser.field_start;
+    this.field_len = p-this.field_start;
   }
 	break;
 	case 4:
-// line 23 "ext/puma_http11/http11_parser.java.rl"
-	{ parser.mark = p; }
+// line 24 "ext/puma_http11/http11_parser.java.rl"
+	{ this.mark = p; }
 	break;
 	case 5:
-// line 24 "ext/puma_http11/http11_parser.java.rl"
+// line 25 "ext/puma_http11/http11_parser.java.rl"
 	{
-    Http11.http_field(runtime, parser.data, parser.buffer, parser.field_start, parser.field_len, parser.mark, p-parser.mark);
+    Http11.http_field(runtime, envStrings, this, p-this.mark);
   }
 	break;
 	case 6:
-// line 27 "ext/puma_http11/http11_parser.java.rl"
+// line 28 "ext/puma_http11/http11_parser.java.rl"
 	{
-    Http11.request_method(runtime, parser.data, parser.buffer, parser.mark, p-parser.mark);
+    Http11.request_method(runtime, envStrings, this, p-this.mark);
   }
 	break;
 	case 7:
-// line 30 "ext/puma_http11/http11_parser.java.rl"
+// line 31 "ext/puma_http11/http11_parser.java.rl"
 	{
-    Http11.request_uri(runtime, parser.data, parser.buffer, parser.mark, p-parser.mark);
+    Http11.request_uri(runtime, envStrings, this, p-this.mark);
   }
 	break;
 	case 8:
-// line 33 "ext/puma_http11/http11_parser.java.rl"
+// line 34 "ext/puma_http11/http11_parser.java.rl"
 	{
-    Http11.fragment(runtime, parser.data, parser.buffer, parser.mark, p-parser.mark);
+    Http11.fragment(runtime, envStrings, this, p-this.mark);
   }
 	break;
 	case 9:
-// line 37 "ext/puma_http11/http11_parser.java.rl"
-	{parser.query_start = p; }
+// line 38 "ext/puma_http11/http11_parser.java.rl"
+	{this.query_start = p; }
 	break;
 	case 10:
-// line 38 "ext/puma_http11/http11_parser.java.rl"
+// line 39 "ext/puma_http11/http11_parser.java.rl"
 	{
-    Http11.query_string(runtime, parser.data, parser.buffer, parser.query_start, p-parser.query_start);
+    Http11.query_string(runtime, envStrings, this, p-this.query_start);
   }
 	break;
 	case 11:
-// line 42 "ext/puma_http11/http11_parser.java.rl"
+// line 43 "ext/puma_http11/http11_parser.java.rl"
 	{
-    Http11.server_protocol(runtime, parser.data, parser.buffer, parser.mark, p-parser.mark);
+    Http11.server_protocol(runtime, envStrings, this, p-this.mark);
   }
 	break;
 	case 12:
-// line 46 "ext/puma_http11/http11_parser.java.rl"
+// line 47 "ext/puma_http11/http11_parser.java.rl"
 	{
-    Http11.request_path(runtime, parser.data, parser.buffer, parser.mark, p-parser.mark);
+    Http11.request_path(runtime, envStrings, this, p-this.mark);
   }
 	break;
 	case 13:
-// line 50 "ext/puma_http11/http11_parser.java.rl"
+// line 51 "ext/puma_http11/http11_parser.java.rl"
 	{ 
-    parser.body_start = p + 1;
-    http.header_done(runtime, parser.data, parser.buffer, p + 1, pe - p - 1);
+    this.body_start = p + 1;
+    http.header_done(runtime, this, p + 1, pe - p - 1);
     { p += 1; _goto_targ = 5; if (true)  continue _goto;}
   }
 	break;
-// line 404 "ext/puma_http11/org/jruby/puma/Http11Parser.java"
+// line 390 "ext/puma_http11/org/jruby/puma/Http11Parser.java"
 			}
 		}
 	}
@@ -420,19 +406,19 @@ case 5:
 	break; }
 	}
 
-// line 114 "ext/puma_http11/http11_parser.java.rl"
+// line 100 "ext/puma_http11/http11_parser.java.rl"
 
-     parser.cs = cs;
-     parser.nread += (p - off);
+     this.cs = cs;
+     this.nread += (p - off);
      
      assert p <= pe                  : "buffer overflow after parsing execute";
-     assert parser.nread <= len      : "nread longer than length";
-     assert parser.body_start <= len : "body starts after buffer end";
-     assert parser.mark < len        : "mark is after buffer end";
-     assert parser.field_len <= len  : "field has length longer than whole buffer";
-     assert parser.field_start < len : "field starts after buffer end";
+     assert this.nread <= len      : "nread longer than length";
+     assert this.body_start <= len : "body starts after buffer end";
+     assert this.mark < len        : "mark is after buffer end";
+     assert this.field_len <= len  : "field has length longer than whole buffer";
+     assert this.field_start < len : "field starts after buffer end";
 
-     return parser.nread;
+     return this.nread;
    }
 
    public int finish() {
@@ -446,10 +432,10 @@ case 5:
   }
 
   public boolean has_error() {
-    return parser.cs == puma_parser_error;
+    return this.cs == puma_parser_error;
   }
 
   public boolean is_finished() {
-    return parser.cs == puma_parser_first_final;
+    return this.cs == puma_parser_first_final;
   }
 }

data/ext/puma_http11/puma_http11.c

@@ -8,25 +8,12 @@
 
 #include "ruby.h"
 #include "ruby/encoding.h"
-#include "ext_help.h"
 #include <assert.h>
 #include <string.h>
 #include <ctype.h>
 #include "http11_parser.h"
 
-#ifndef MANAGED_STRINGS
-
-#ifndef RSTRING_PTR
-#define RSTRING_PTR(s) (RSTRING(s)->ptr)
-#endif
-#ifndef RSTRING_LEN
-#define RSTRING_LEN(s) (RSTRING(s)->len)
-#endif
-
-#define rb_extract_chars(e, sz) (*sz = RSTRING_LEN(e), RSTRING_PTR(e))
-#define rb_free_chars(e) /* nothing */
-
-#endif
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
 
 static VALUE eHttpParserError;
 
@@ -51,8 +38,8 @@ static VALUE global_request_path;
 /** Defines global strings in the init method. */
 static inline void DEF_GLOBAL(VALUE *var, const char *cstr)
 {
-    rb_global_variable(var);
-    *var = rb_enc_interned_str_cstr(cstr, rb_utf8_encoding());
+  rb_global_variable(var);
+  *var = rb_enc_interned_str_cstr(cstr, rb_utf8_encoding());
 }
 
 /* Defines the maximum allowed lengths for various input elements.*/
@@ -77,10 +64,10 @@ DEF_MAX_LENGTH(QUERY_STRING, PUMA_QUERY_STRING_MAX_LENGTH);
 DEF_MAX_LENGTH(HEADER, (1024 * (80 + 32)));
 
 struct common_field {
-	const size_t len;
-	const char *name;
+  const size_t len;
+  const char *name;
   int raw;
-	VALUE value;
+  VALUE value;
 };
 
 /*
@@ -91,42 +78,42 @@ struct common_field {
 static struct common_field common_http_fields[] = {
 # define f(N) { (sizeof(N) - 1), N, 0, Qnil }
 # define fr(N) { (sizeof(N) - 1), N, 1, Qnil }
-	f("ACCEPT"),
-	f("ACCEPT_CHARSET"),
-	f("ACCEPT_ENCODING"),
-	f("ACCEPT_LANGUAGE"),
-	f("ALLOW"),
-	f("AUTHORIZATION"),
-	f("CACHE_CONTROL"),
-	f("CONNECTION"),
-	f("CONTENT_ENCODING"),
-	fr("CONTENT_LENGTH"),
-	fr("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")
+  f("ACCEPT"),
+  f("ACCEPT_CHARSET"),
+  f("ACCEPT_ENCODING"),
+  f("ACCEPT_LANGUAGE"),
+  f("ALLOW"),
+  f("AUTHORIZATION"),
+  f("CACHE_CONTROL"),
+  f("CONNECTION"),
+  f("CONTENT_ENCODING"),
+  fr("CONTENT_LENGTH"),
+  fr("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
 };
 
@@ -140,10 +127,10 @@ static void init_common_fields(void)
   for(i = 0; i < ARRAY_SIZE(common_http_fields); cf++, i++) {
     rb_global_variable(&cf->value);
     if(cf->raw) {
-      cf->value = rb_str_new(cf->name, cf->len);
+      cf->value = rb_enc_interned_str(cf->name, cf->len, rb_utf8_encoding());
     } else {
       memcpy(tmp + HTTP_PREFIX_LEN, cf->name, cf->len + 1);
-      cf->value = rb_str_new(tmp, HTTP_PREFIX_LEN + cf->len);
+      cf->value = rb_enc_interned_str(tmp, HTTP_PREFIX_LEN + cf->len, rb_utf8_encoding());
     }
   }
 }
@@ -163,7 +150,7 @@ static int is_ows(const char c) {
     return c == ' ' || c == '\t';
 }
 
-void http_field(puma_parser* hp, const char *field, size_t flen,
+static void http_field(puma_parser* hp, const char *field, size_t flen,
                                  const char *value, size_t vlen)
 {
   VALUE f = Qnil;
@@ -186,7 +173,7 @@ void http_field(puma_parser* hp, const char *field, size_t flen,
     memcpy(hp->buf, HTTP_PREFIX, HTTP_PREFIX_LEN);
     memcpy(hp->buf + HTTP_PREFIX_LEN, field, flen);
 
-    f = rb_str_new(hp->buf, new_size);
+    f = rb_enc_interned_str(hp->buf, new_size, rb_utf8_encoding());
   }
 
   while (vlen > 0 && is_ows(value[vlen - 1])) vlen--;
@@ -208,7 +195,7 @@ void http_field(puma_parser* hp, const char *field, size_t flen,
   }
 }
 
-void request_method(puma_parser* hp, const char *at, size_t length)
+static void request_method(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = Qnil;
 
@@ -216,7 +203,7 @@ void request_method(puma_parser* hp, const char *at, size_t length)
   rb_hash_aset(hp->request, global_request_method, val);
 }
 
-void request_uri(puma_parser* hp, const char *at, size_t length)
+static void request_uri(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = Qnil;
 
@@ -226,7 +213,7 @@ void request_uri(puma_parser* hp, const char *at, size_t length)
   rb_hash_aset(hp->request, global_request_uri, val);
 }
 
-void fragment(puma_parser* hp, const char *at, size_t length)
+static void fragment(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = Qnil;
 
@@ -236,7 +223,7 @@ void fragment(puma_parser* hp, const char *at, size_t length)
   rb_hash_aset(hp->request, global_fragment, val);
 }
 
-void request_path(puma_parser* hp, const char *at, size_t length)
+static void request_path(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = Qnil;
 
@@ -246,7 +233,7 @@ void request_path(puma_parser* hp, const char *at, size_t length)
   rb_hash_aset(hp->request, global_request_path, val);
 }
 
-void query_string(puma_parser* hp, const char *at, size_t length)
+static void query_string(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = Qnil;
 
@@ -256,7 +243,7 @@ void query_string(puma_parser* hp, const char *at, size_t length)
   rb_hash_aset(hp->request, global_query_string, val);
 }
 
-void server_protocol(puma_parser* hp, const char *at, size_t length)
+static void server_protocol(puma_parser* hp, const char *at, size_t length)
 {
   VALUE val = rb_str_new(at, length);
   rb_hash_aset(hp->request, global_server_protocol, val);
@@ -265,36 +252,42 @@ void server_protocol(puma_parser* hp, const char *at, size_t length)
 /** Finalizes the request header to have a bunch of stuff that's
   needed. */
 
-void header_done(puma_parser* hp, const char *at, size_t length)
+static void header_done(puma_parser* hp, const char *at, size_t length)
 {
   hp->body = rb_str_new(at, length);
 }
 
 
-void HttpParser_free(void *data) {
-  TRACE();
+static void HttpParser_mark(void *ptr) {
+  puma_parser *hp = ptr;
+  rb_gc_mark_movable(hp->request);
+  rb_gc_mark_movable(hp->body);
+}
 
-  if(data) {
-    xfree(data);
-  }
+static size_t HttpParser_size(const void *ptr) {
+  return sizeof(puma_parser);
 }
 
-void HttpParser_mark(void *ptr) {
+static void HttpParser_compact(void *ptr) {
   puma_parser *hp = ptr;
-  if(hp->request) rb_gc_mark(hp->request);
-  if(hp->body) rb_gc_mark(hp->body);
+  hp->request = rb_gc_location(hp->request);
+  hp->body = rb_gc_location(hp->body);
 }
 
-const rb_data_type_t HttpParser_data_type = {
-    "HttpParser",
-    { HttpParser_mark, HttpParser_free, 0 },
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY,
+static const rb_data_type_t HttpParser_data_type = {
+    .wrap_struct_name = "Puma::HttpParser",
+    .function = {
+      .dmark = HttpParser_mark,
+      .dfree = RUBY_TYPED_DEFAULT_FREE,
+      .dsize = HttpParser_size,
+      .dcompact = HttpParser_compact,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-VALUE HttpParser_alloc(VALUE klass)
+static VALUE HttpParser_alloc(VALUE klass)
 {
   puma_parser *hp = ALLOC_N(puma_parser, 1);
-  TRACE();
   hp->http_field = http_field;
   hp->request_method = request_method;
   hp->request_uri = request_uri;
@@ -310,16 +303,25 @@ VALUE HttpParser_alloc(VALUE klass)
   return TypedData_Wrap_Struct(klass, &HttpParser_data_type, hp);
 }
 
+static inline puma_parser *HttpParser_unwrap(VALUE self)
+{
+  puma_parser *http;
+  TypedData_Get_Struct(self, puma_parser, &HttpParser_data_type, http);
+  if (http == NULL) {
+    rb_raise(rb_eArgError, "%s", "NULL http_parser found");
+  }
+  return http;
+}
+
 /**
  * call-seq:
  *    parser.new -> parser
  *
  * Creates a new parser.
  */
-VALUE HttpParser_init(VALUE self)
+static VALUE HttpParser_init(VALUE self)
 {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+  puma_parser *http = HttpParser_unwrap(self);
   puma_parser_init(http);
 
   return self;
@@ -333,10 +335,9 @@ VALUE HttpParser_init(VALUE self)
  * Resets the parser to it's initial state so that you can reuse it
  * rather than making new ones.
  */
-VALUE HttpParser_reset(VALUE self)
+static VALUE HttpParser_reset(VALUE self)
 {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+  puma_parser *http = HttpParser_unwrap(self);
   puma_parser_init(http);
 
   return Qnil;
@@ -350,10 +351,9 @@ VALUE HttpParser_reset(VALUE self)
  * Finishes a parser early which could put in a "good" or bad state.
  * You should call reset after finish it or bad things will happen.
  */
-VALUE HttpParser_finish(VALUE self)
+static VALUE HttpParser_finish(VALUE self)
 {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+  puma_parser *http = HttpParser_unwrap(self);
   puma_parser_finish(http);
 
   return puma_parser_is_finished(http) ? Qtrue : Qfalse;
@@ -377,26 +377,22 @@ VALUE HttpParser_finish(VALUE self)
  * the parsing from that position.  It needs all of the original data as well
  * so you have to append to the data buffer as you read.
  */
-VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
+static VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
 {
-  puma_parser *http = NULL;
+  puma_parser *http = HttpParser_unwrap(self);
   int from = 0;
   char *dptr = NULL;
   long dlen = 0;
 
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
-
   from = FIX2INT(start);
-  dptr = rb_extract_chars(data, &dlen);
+  RSTRING_GETMEM(data, dptr, dlen);
 
   if(from >= dlen) {
-    rb_free_chars(dptr);
     rb_raise(eHttpParserError, "%s", "Requested start is after data buffer end.");
   } else {
     http->request = req_hash;
     puma_parser_execute(http, dptr, dlen, from);
 
-    rb_free_chars(dptr);
     VALIDATE_MAX_LENGTH(puma_parser_nread(http), HEADER);
 
     if(puma_parser_has_error(http)) {
@@ -415,10 +411,9 @@ VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
  *
  * Tells you whether the parser is in an error state.
  */
-VALUE HttpParser_has_error(VALUE self)
+static VALUE HttpParser_has_error(VALUE self)
 {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+  puma_parser *http = HttpParser_unwrap(self);
 
   return puma_parser_has_error(http) ? Qtrue : Qfalse;
 }
@@ -430,10 +425,9 @@ VALUE HttpParser_has_error(VALUE self)
  *
  * Tells you whether the parser is finished or not and in a good state.
  */
-VALUE HttpParser_is_finished(VALUE self)
+static VALUE HttpParser_is_finished(VALUE self)
 {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+  puma_parser *http = HttpParser_unwrap(self);
 
   return puma_parser_is_finished(http) ? Qtrue : Qfalse;
 }
@@ -446,10 +440,9 @@ VALUE HttpParser_is_finished(VALUE self)
  * Returns the amount of data processed so far during this processing cycle.  It is
  * set to 0 on initialize or reset calls and is incremented each time execute is called.
  */
-VALUE HttpParser_nread(VALUE self)
+static VALUE HttpParser_nread(VALUE self)
 {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+  puma_parser *http = HttpParser_unwrap(self);
 
   return INT2FIX(http->nread);
 }
@@ -460,9 +453,8 @@ VALUE HttpParser_nread(VALUE self)
  *
  * If the request included a body, returns it.
  */
-VALUE HttpParser_body(VALUE self) {
-  puma_parser *http = NULL;
-  DATA_GET(self, puma_parser, &HttpParser_data_type, http);
+static VALUE HttpParser_body(VALUE self) {
+  puma_parser *http = HttpParser_unwrap(self);
 
   return http->body;
 }
@@ -471,7 +463,7 @@ VALUE HttpParser_body(VALUE self) {
 void Init_mini_ssl(VALUE mod);
 #endif
 
-void Init_puma_http11(void)
+RUBY_FUNC_EXPORTED void Init_puma_http11(void)
 {
 #ifdef HAVE_RB_EXT_RACTOR_SAFE
   rb_ext_ractor_safe(true);