h1p 0.4 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a27a3323482c8a0cec845e60962516b755338ccc54d0ba76bf6716bbb449a8ff
-  data.tar.gz: 22613ade68e261e3fca56cafcab410b1bed4587efe8c1da4ef52d1d335bc7efd
+  metadata.gz: 53aadd6f6c4ae112ff844b68e8325fe334d51dd0a09bb11cc54d017190e97677
+  data.tar.gz: e9f6d504813d74c050a46b4e973e9fbc227dd790c02395a0073b62f43a7393da
 SHA512:
-  metadata.gz: 36cb9020745437627ad3dca5f83de6f81f8ad6e04075909db192a509b9f022960c5a7768c1f1ab8fdb807ae0d7b54e6febbc76581e68475c5f27057ff5b7aeb5
-  data.tar.gz: 20943cfead5e0236e60cb3a0d70057c69a91bbde45973f0f4ff87f38a1866523c1a02132254eebc13b8c5e2c4f75cd8e5791246257a792f63391cff88a6e1011
+  metadata.gz: 3ac98c2d7e702f8cf5f9052e78e9abe486ee3ba0814c4c16fe222acdccfb5338ac9d5c9b4a5d1da2178fca65472693c94a4997cc86de05db70f13c90f1bc767e
+  data.tar.gz: 73ce78e3435eb40f3e6d46ee8eef803284e8da99f32d610dbd723c3661548a74ed454ae70e1ec02dcfbdb70aa346059fb7713eab19de3e6e6e65a4ca859926c7

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.5 2022-03-19
+
+- Implement `Parser#splice_body_to` (#3)
+
 ## 0.4 2022-02-28
 
 - Rename `__parser_read_method__` to `__read_method__`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    h1p (0.4)
+    h1p (0.5)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -26,6 +26,8 @@ The H1P was originally written as part of
 - Parses both HTTP request and HTTP response
 - Support for chunked encoding
 - Support for both `LF` and `CRLF` line breaks
+- Support for **splicing** request/response bodies (when used with
+  [Polyphony](https://github.com/digital-fabric/polyphony))
 - Track total incoming traffic
 
 ## Installing
@@ -161,6 +163,36 @@ end
 The `#read_body` and `#read_body_chunk` methods will return `nil` if no body is
 expected (based on the received headers).
 
+## Splicing request/response bodies
+
+> Splicing of request/response bodies is available only on Linux, and works only
+> with [Polyphony](https://github.com/digital-fabric/polyphony).
+
+H1P also lets you [splice](https://man7.org/linux/man-pages/man2/splice.2.html)
+request or response bodies directly to a pipe. This is particularly useful for
+uploading or downloading large files, as the data does not need to be loaded
+into Ruby strings. In fact, the data will stay almost entirely in kernel
+buffers, which means any data copying is reduced to the absolute minimum.
+
+The following example sends a request, then splices the response body to a file:
+
+```ruby
+require 'polyphony'
+require 'h1p'
+
+socket = TCPSocket.new('example.com', 80)
+socket << "GET /bigfile HTTP/1.1\r\nHost: example.com\r\n\r\n"
+
+parser = H1P::Parser.new(socket, :client)
+headers = parser.parse_headers
+
+pipe = Polyphony.pipe
+File.open('bigfile', 'w+') do |f|
+  spin { parser.splice_body_to(pipe) }
+  f.splice_from(pipe)
+end
+```
+
 ## Parsing from arbitrary transports
 
 The H1P parser was built to read from any arbitrary transport or source, as long

data/ext/h1p/h1p.c

@@ -16,6 +16,9 @@
 ID ID_arity;
 ID ID_backend_read;
 ID ID_backend_recv;
+ID ID_backend_send;
+ID ID_backend_splice;
+ID ID_backend_write;
 ID ID_call;
 ID ID_downcase;
 ID ID_eof_p;
@@ -25,8 +28,8 @@ ID ID_read;
 ID ID_readpartial;
 ID ID_to_i;
 ID ID_upcase;
+ID ID_write_method;
 
-static VALUE mPolyphony = Qnil;
 static VALUE cError;
 
 VALUE NUM_max_headers_read_length;
@@ -46,17 +49,24 @@ VALUE STR_transfer_encoding;
 
 VALUE SYM_backend_read;
 VALUE SYM_backend_recv;
+VALUE SYM_backend_send;
+VALUE SYM_backend_write;
 VALUE SYM_stock_readpartial;
 
 VALUE SYM_client;
 VALUE SYM_server;
 
 enum read_method {
-  method_readpartial,       // receiver.readpartial(len, buf, pos, raise_on_eof: false) (Polyphony-specific)
-  method_backend_read,      // Polyphony.backend_read (Polyphony-specific)
-  method_backend_recv,      // Polyphony.backend_recv (Polyphony-specific)
-  method_call,              // receiver.call(len) (Universal)
-  method_stock_readpartial  // receiver.readpartial(len)
+  RM_READPARTIAL,       // receiver.readpartial(len, buf, pos, raise_on_eof: false) (Polyphony-specific)
+  RM_BACKEND_READ,      // Polyphony.backend_read (Polyphony-specific)
+  RM_BACKEND_RECV,      // Polyphony.backend_recv (Polyphony-specific)
+  RM_CALL,              // receiver.call(len) (Universal)
+  RM_STOCK_READPARTIAL  // receiver.readpartial(len)
+};
+
+enum write_method {
+  WM_BACKEND_WRITE,
+  WM_BACKEND_SEND
 };
 
 enum parser_mode {
@@ -115,31 +125,40 @@ static VALUE Parser_allocate(VALUE klass) {
 #define GetParser(obj, parser) \
   TypedData_Get_Struct((obj), Parser_t, &Parser_type, (parser))
 
-static inline void get_polyphony() {
-  if (mPolyphony != Qnil) return;
-
-  mPolyphony = rb_const_get(rb_cObject, rb_intern("Polyphony"));
-  rb_gc_register_mark_object(mPolyphony);
+static inline VALUE Polyphony() {
+  static VALUE mPolyphony = Qnil;
+  if (mPolyphony == Qnil) {
+    mPolyphony = rb_const_get(rb_cObject, rb_intern("Polyphony"));
+    rb_gc_register_mark_object(mPolyphony);
+  }
+  return mPolyphony;
 }
 
-enum read_method detect_read_method(VALUE io) {
+static enum read_method detect_read_method(VALUE io) {
   if (rb_respond_to(io, ID_read_method)) {
     VALUE method = rb_funcall(io, ID_read_method, 0);
-    if (method == SYM_stock_readpartial) return method_stock_readpartial;
-
-    get_polyphony();
-    if (method == SYM_backend_read)      return method_backend_read;
-    if (method == SYM_backend_recv)      return method_backend_recv;
+    if (method == SYM_stock_readpartial) return RM_STOCK_READPARTIAL;
+    if (method == SYM_backend_read)      return RM_BACKEND_READ;
+    if (method == SYM_backend_recv)      return RM_BACKEND_RECV;
 
-    return method_readpartial;
+    return RM_READPARTIAL;
   }
   else if (rb_respond_to(io, ID_call)) {
-    return method_call;
+    return RM_CALL;
   }
   else
     rb_raise(rb_eRuntimeError, "Provided reader should be a callable or respond to #__read_method__");
 }
 
+static enum write_method detect_write_method(VALUE io) {
+  if (rb_respond_to(io, ID_write_method)) {
+    VALUE method = rb_funcall(io, ID_write_method, 0);
+    if (method == SYM_backend_write)  return WM_BACKEND_WRITE;
+    if (method == SYM_backend_send)   return WM_BACKEND_SEND;
+  }
+  rb_raise(rb_eRuntimeError, "Provided io should respond to #__write_method__");
+}
+
 enum parser_mode parse_parser_mode(VALUE mode) {
   if (mode == SYM_server) return mode_server;
   if (mode == SYM_client) return mode_client;
@@ -246,7 +265,7 @@ VALUE Parser_initialize(VALUE self, VALUE io, VALUE mode) {
 }
 
 #define SET_HEADER_VALUE_INT(parser, key, value) { \
-  rb_hash_aset(parser->headers, key, INT2NUM(value)); \
+  rb_hash_aset(parser->headers, key, INT2FIX(value)); \
 }
 
 #define CONSUME_CRLF(parser) { \
@@ -294,21 +313,37 @@ static inline VALUE io_stock_readpartial(VALUE io, VALUE maxlen, VALUE buf, VALU
 
 static inline VALUE parser_io_read(Parser_t *parser, VALUE maxlen, VALUE buf, VALUE buf_pos) {
   switch (parser->read_method) {
-    case method_backend_read:
-      return rb_funcall(mPolyphony, ID_backend_read, 5, parser->io, buf, maxlen, Qfalse, buf_pos);
-    case method_backend_recv:
-      return rb_funcall(mPolyphony, ID_backend_recv, 4, parser->io, buf, maxlen, buf_pos);
-    case method_readpartial:
-      return rb_funcall(parser->    io, ID_readpartial, 4, maxlen, buf, buf_pos, Qfalse);
-    case method_call:
-      return io_call(parser    ->io, maxlen, buf, buf_pos);
-    case method_stock_readpartial:
+    case RM_BACKEND_READ:
+      return rb_funcall(Polyphony(), ID_backend_read, 5, parser->io, buf, maxlen, Qfalse, buf_pos);
+    case RM_BACKEND_RECV:
+      return rb_funcall(Polyphony(), ID_backend_recv, 4, parser->io, buf, maxlen, buf_pos);
+    case RM_READPARTIAL:
+      return rb_funcall(parser->io, ID_readpartial, 4, maxlen, buf, buf_pos, Qfalse);
+    case RM_CALL:
+      return io_call(parser->io, maxlen, buf, buf_pos);
+    case RM_STOCK_READPARTIAL:
       return io_stock_readpartial(parser->io, maxlen, buf, buf_pos);
     default:
       return Qnil;
   }
 }
 
+static inline VALUE parser_io_write(VALUE io, VALUE buf, enum write_method method) {
+  switch (method) {
+    case WM_BACKEND_WRITE:
+      return rb_funcall(Polyphony(), ID_backend_write, 2, io, buf);
+    case WM_BACKEND_SEND:
+      return rb_funcall(Polyphony(), ID_backend_send, 3, io, buf, INT2FIX(0));
+    default:
+      return Qnil;
+  }
+}
+
+static inline int parser_io_splice(VALUE src, VALUE dest, int len) {
+  VALUE ret = rb_funcall(Polyphony(), ID_backend_splice, 3, src, dest, INT2FIX(len));
+  return FIX2INT(ret);
+}
+
 static inline int fill_buffer(Parser_t *parser) {
   VALUE ret = parser_io_read(parser, NUM_max_headers_read_length, parser->buffer, NUM_buffer_end);
   if (ret == Qnil) return 0;
@@ -705,7 +740,7 @@ done:
 
   parser->current_request_rx += read_bytes;
   if (parser->headers != Qnil)
-    rb_hash_aset(parser->headers, STR_pseudo_rx, INT2NUM(read_bytes));
+    rb_hash_aset(parser->headers, STR_pseudo_rx, INT2FIX(read_bytes));
   return parser->headers;
 }
 
@@ -754,7 +789,7 @@ VALUE read_body_with_content_length(Parser_t *parser, int read_entire_body, int
 
   while (parser->body_left) {
     int maxlen = parser->body_left <= MAX_BODY_READ_LENGTH ? parser->body_left : MAX_BODY_READ_LENGTH;
-    VALUE tmp_buf = parser_io_read(parser, INT2NUM(maxlen), Qnil, NUM_buffer_start);
+    VALUE tmp_buf = parser_io_read(parser, INT2FIX(maxlen), Qnil, NUM_buffer_start);
     if (tmp_buf == Qnil) goto eof;
     if (body != Qnil)
       rb_str_append(body, tmp_buf);
@@ -768,7 +803,7 @@ VALUE read_body_with_content_length(Parser_t *parser, int read_entire_body, int
     if (!read_entire_body) goto done;
   }
 done:
-  rb_hash_aset(parser->headers, STR_pseudo_rx, INT2NUM(parser->current_request_rx));
+  rb_hash_aset(parser->headers, STR_pseudo_rx, INT2FIX(parser->current_request_rx));
   RB_GC_GUARD(body);
   return body;
 eof:
@@ -836,7 +871,7 @@ int read_body_chunk_with_chunked_encoding(Parser_t *parser, VALUE *body, int chu
   while (left) {
     int maxlen = left <= MAX_BODY_READ_LENGTH ? left : MAX_BODY_READ_LENGTH;
 
-    VALUE tmp_buf = parser_io_read(parser, INT2NUM(maxlen), Qnil, NUM_buffer_start);
+    VALUE tmp_buf = parser_io_read(parser, INT2FIX(maxlen), Qnil, NUM_buffer_start);
     if (tmp_buf == Qnil) goto eof;
     if (*body != Qnil)
       rb_str_append(*body, tmp_buf);
@@ -852,6 +887,33 @@ eof:
   return 0;
 }
 
+int splice_body_chunk_with_chunked_encoding(Parser_t *parser, VALUE dest, int chunk_size, enum write_method method) {
+  int len = RSTRING_LEN(parser->buffer);
+  int pos = BUFFER_POS(parser);
+  int left = chunk_size;
+
+  if (pos < len) {
+    int available = len - pos;
+    if (available > left) available = left;
+    VALUE buf = rb_str_new(RSTRING_PTR(parser->buffer) + pos, available);
+    BUFFER_POS(parser) += available;
+    parser->current_request_rx += available;
+    parser_io_write(dest, buf, method);
+    RB_GC_GUARD(buf);
+    left -= available;
+  }
+
+  while (left) {
+    int spliced = parser_io_splice(parser->io, dest, left);
+    if (!spliced) goto eof;
+    parser->current_request_rx += spliced;
+    left -= spliced;
+  }
+  return 1;
+eof:
+  return 0;
+}
+
 static inline int parse_chunk_postfix(Parser_t *parser) {
   int initial_pos = BUFFER_POS(parser);
   if (initial_pos == BUFFER_LEN(parser)) FILL_BUFFER_OR_GOTO_EOF(parser);
@@ -897,11 +959,70 @@ bad_request:
 eof:
   RAISE_BAD_REQUEST("Incomplete request body");
 done:
-  rb_hash_aset(parser->headers, STR_pseudo_rx, INT2NUM(parser->current_request_rx));
+  rb_hash_aset(parser->headers, STR_pseudo_rx, INT2FIX(parser->current_request_rx));
   RB_GC_GUARD(body);
   return body;
 }
 
+void splice_body_with_chunked_encoding(Parser_t *parser, VALUE dest, enum write_method method) {
+  buffer_trim(parser);
+  INIT_PARSER_STATE(parser);
+
+  while (1) {
+    int chunk_size = 0;
+    if (BUFFER_POS(parser) == BUFFER_LEN(parser)) FILL_BUFFER_OR_GOTO_EOF(parser);
+    if (!parse_chunk_size(parser, &chunk_size)) goto bad_request;
+
+    if (chunk_size) {
+      if (!splice_body_chunk_with_chunked_encoding(parser, dest, chunk_size, method))
+        goto bad_request;
+    }
+    else
+      parser->request_completed = 1;
+
+    // read post-chunk delimiter ("\r\n")
+    if (!parse_chunk_postfix(parser)) goto bad_request;
+    if (!chunk_size) goto done;
+  }
+bad_request:
+  RAISE_BAD_REQUEST("Malformed request body");
+eof:
+  RAISE_BAD_REQUEST("Incomplete request body");
+done:
+  rb_hash_aset(parser->headers, STR_pseudo_rx, INT2FIX(parser->current_request_rx));
+}
+
+void splice_body_with_content_length(Parser_t *parser, VALUE dest, enum write_method method)  {
+  if (parser->body_left <= 0) return;
+
+  int len = RSTRING_LEN(parser->buffer);
+  int pos = BUFFER_POS(parser);
+
+  if (pos < len) {
+    int available = len - pos;
+    if (available > parser->body_left) available = parser->body_left;
+    VALUE buf = rb_str_new(RSTRING_PTR(parser->buffer) + pos, available);
+    BUFFER_POS(parser) += available;
+    parser_io_write(dest, buf, method);
+    RB_GC_GUARD(buf);
+    parser->current_request_rx += available;
+    parser->body_left -= available;
+    if (!parser->body_left) parser->request_completed = 1;
+  }
+
+  while (parser->body_left) {
+    int spliced = parser_io_splice(parser->io, dest, parser->body_left);
+    if (!spliced) goto eof;
+    parser->current_request_rx += spliced;
+    parser->body_left -= spliced;
+  }
+done:
+  rb_hash_aset(parser->headers, STR_pseudo_rx, INT2FIX(parser->current_request_rx));
+  return;
+eof:
+  RAISE_BAD_REQUEST("Incomplete body");
+}
+
 static inline void detect_body_read_mode(Parser_t *parser) {
   VALUE content_length = rb_hash_aref(parser->headers, STR_content_length);
   if (content_length != Qnil) {
@@ -931,7 +1052,8 @@ static inline VALUE read_body(VALUE self, int read_entire_body, int buffered_onl
 
   if (parser->body_read_mode == BODY_READ_MODE_CHUNKED)
     return read_body_with_chunked_encoding(parser, read_entire_body, buffered_only);
-  return read_body_with_content_length(parser, read_entire_body, buffered_only);
+  else
+    return read_body_with_content_length(parser, read_entire_body, buffered_only);
 }
 
 VALUE Parser_read_body(VALUE self) {
@@ -942,6 +1064,22 @@ VALUE Parser_read_body_chunk(VALUE self, VALUE buffered_only) {
   return read_body(self, 0, buffered_only == Qtrue);
 }
 
+VALUE Parser_splice_body_to(VALUE self, VALUE dest) {
+  Parser_t *parser;
+  GetParser(self, parser);
+  enum write_method method = detect_write_method(dest);
+
+  if (parser->body_read_mode == BODY_READ_MODE_UNKNOWN)
+    detect_body_read_mode(parser);
+
+  if (parser->body_read_mode == BODY_READ_MODE_CHUNKED)
+    splice_body_with_chunked_encoding(parser, dest, method);
+  else
+    splice_body_with_content_length(parser, dest, method);
+  
+  return self;
+}
+
 VALUE Parser_complete_p(VALUE self) {
   Parser_t *parser;
   GetParser(self, parser);
@@ -969,24 +1107,29 @@ void Init_H1P() {
   rb_define_method(cParser, "parse_headers", Parser_parse_headers, 0);
   rb_define_method(cParser, "read_body", Parser_read_body, 0);
   rb_define_method(cParser, "read_body_chunk", Parser_read_body_chunk, 1);
+  rb_define_method(cParser, "splice_body_to", Parser_splice_body_to, 1);
   rb_define_method(cParser, "complete?", Parser_complete_p, 0);
 
   ID_arity                  = rb_intern("arity");
   ID_backend_read           = rb_intern("backend_read");
   ID_backend_recv           = rb_intern("backend_recv");
+  ID_backend_send           = rb_intern("backend_send");
+  ID_backend_splice         = rb_intern("backend_splice");
+  ID_backend_write          = rb_intern("backend_write");
   ID_call                   = rb_intern("call");
   ID_downcase               = rb_intern("downcase");
   ID_eof_p                  = rb_intern("eof?");
   ID_eq                     = rb_intern("==");
-  ID_read_method     = rb_intern("__read_method__");
+  ID_read_method            = rb_intern("__read_method__");
   ID_read                   = rb_intern("read");
   ID_readpartial            = rb_intern("readpartial");
   ID_to_i                   = rb_intern("to_i");
   ID_upcase                 = rb_intern("upcase");
+  ID_write_method           = rb_intern("__write_method__");
 
-  NUM_max_headers_read_length = INT2NUM(MAX_HEADERS_READ_LENGTH);
-  NUM_buffer_start = INT2NUM(0);
-  NUM_buffer_end = INT2NUM(-1);
+  NUM_max_headers_read_length = INT2FIX(MAX_HEADERS_READ_LENGTH);
+  NUM_buffer_start = INT2FIX(0);
+  NUM_buffer_end = INT2FIX(-1);
 
   GLOBAL_STR(STR_pseudo_method,         ":method");
   GLOBAL_STR(STR_pseudo_path,           ":path");
@@ -999,8 +1142,11 @@ void Init_H1P() {
   GLOBAL_STR(STR_content_length,        "content-length");
   GLOBAL_STR(STR_transfer_encoding,     "transfer-encoding");
 
-  SYM_backend_read = ID2SYM(ID_backend_read);
-  SYM_backend_recv = ID2SYM(ID_backend_recv);
+  SYM_backend_read  = ID2SYM(ID_backend_read);
+  SYM_backend_recv  = ID2SYM(ID_backend_recv);
+  SYM_backend_send  = ID2SYM(ID_backend_send);
+  SYM_backend_write = ID2SYM(ID_backend_write);
+
   SYM_stock_readpartial = ID2SYM(rb_intern("stock_readpartial"));
   
   SYM_client = ID2SYM(rb_intern("client"));

data/ext/h1p/h1p.h

@@ -14,5 +14,10 @@
   for (unsigned long i = 0; i < size; i++) printf("%s\n", strings[i]); \
   free(strings); \
 }
+#define PRINT_BUFFER(prefix, ptr, len) { \
+  printf("%s buffer (%d): ", prefix, (int)len); \
+  for (int i = 0; i < len; i++) printf("%02X ", ptr[i]); \
+  printf("\n"); \
+}
 
 #endif /* H1P_H */

data/lib/h1p/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module H1P
-  VERSION = '0.4'
+  VERSION = '0.5'
 end

data/lib/h1p.rb

@@ -2,28 +2,34 @@
 
 require_relative './h1p_ext'
 
-unless Object.const_defined?('Polyphony')
-  class IO
+class ::IO
+  if !method_defined?(:__read_method__)
     def __read_method__
       :stock_readpartial
     end
   end
+end
 
-  require 'socket'
+require 'socket'
 
-  class Socket
+class Socket
+  if !method_defined?(:__read_method__)
     def __read_method__
       :stock_readpartial
     end
   end
+end
 
-  class TCPSocket
+class TCPSocket
+  if !method_defined?(:__read_method__)
     def __read_method__
       :stock_readpartial
     end
   end
+end
 
-  class UNIXSocket
+class UNIXSocket
+  if !method_defined?(:__read_method__)
     def __read_method__
       :stock_readpartial
     end

data/test/test_h1p_server.rb

@@ -4,6 +4,7 @@ require_relative 'helper'
 require 'h1p'
 require 'socket'
 require_relative '../ext/h1p/limits'
+require 'securerandom'
 
 class H1PRequestTest < MiniTest::Test
   Error = H1P::Error
@@ -446,6 +447,60 @@ class H1PRequestTest < MiniTest::Test
     assert_raises(H1P::Error) { @parser.read_body_chunk(false) }
   end
 
+  PolyphonyMockup = Object.new
+  def PolyphonyMockup.backend_write(io, buf)
+    io << buf
+  end
+  def PolyphonyMockup.backend_splice(src, dest, len)
+    buf = src.read(len)
+    len = dest.write(buf)
+    len
+  end
+  Object::Polyphony = PolyphonyMockup
+
+  def test_splice_body_to_chunked_encoding
+    req_body = SecureRandom.alphanumeric(60000)
+    req_headers = "POST / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n"
+    r, w = IO.pipe
+
+    Thread.new do
+      @o << req_headers
+      @o << "#{req_body.bytesize.to_s(16)}\r\n"
+      @o << req_body
+      @o << "\r\n0\r\n\r\n"
+      @o.close
+    end
+    def w.__write_method__; :backend_write; end
+    
+    headers = @parser.parse_headers
+    @parser.splice_body_to(w)
+    w.close
+    assert_equal req_body, r.read
+
+    chunk_header_size = "#{req_body.bytesize.to_s(16)}\r\n".bytesize + "\r\n0\r\n\r\n".bytesize
+    assert_equal req_headers.bytesize + req_body.bytesize + chunk_header_size, headers[':rx']
+  end
+
+  def test_splice_body_to_content_length
+    req_body = SecureRandom.alphanumeric(60000)
+    req_headers = "POST / HTTP/1.1\r\nContent-Length: #{req_body.bytesize}\r\n\r\n"
+    r, w = IO.pipe
+
+    Thread.new do
+      @o << req_headers
+      @o << req_body
+      @o.close
+    end
+    def w.__write_method__; :backend_write; end
+    
+    headers = @parser.parse_headers
+    @parser.splice_body_to(w)
+    w.close
+    assert_equal req_body, r.read
+
+    assert_equal req_headers.bytesize + req_body.bytesize, headers[':rx']
+  end
+
   def test_complete?
     @o << "GET / HTTP/1.1\r\n\r\n"
     headers = @parser.parse_headers

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: h1p
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: '0.5'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-28 00:00:00.000000000 Z
+date: 2022-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler