h1p 0.4 → 0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a27a3323482c8a0cec845e60962516b755338ccc54d0ba76bf6716bbb449a8ff
-  data.tar.gz: 22613ade68e261e3fca56cafcab410b1bed4587efe8c1da4ef52d1d335bc7efd
+  metadata.gz: 90f7937fd6bcefdd1627c208bf73054fb3fb03a855666c7247f04aac4398d280
+  data.tar.gz: ab6a866b843beaf92137b991048db9af006f4cb5e510e211dc6ba6652bbc84a2
 SHA512:
-  metadata.gz: 36cb9020745437627ad3dca5f83de6f81f8ad6e04075909db192a509b9f022960c5a7768c1f1ab8fdb807ae0d7b54e6febbc76581e68475c5f27057ff5b7aeb5
-  data.tar.gz: 20943cfead5e0236e60cb3a0d70057c69a91bbde45973f0f4ff87f38a1866523c1a02132254eebc13b8c5e2c4f75cd8e5791246257a792f63391cff88a6e1011
+  metadata.gz: 101e6e13aeed0cf2250dbe962c0c9c9edc5bf69e6ff2a59ee0d02018992c9b76dcaa4be3ddb44bbcb2272e355278a0b717c51050a2786cc95c00fbdb23bc40fa
+  data.tar.gz: 2d3130c067d51f173873d6181b76999dd897c241dcafc5fa3f69ec0837404b2fd7e292cadc2fbf9e27003e3dfd933dc394799abf03f12187d6c80e4f2dab83d6

data/.github/workflows/test.yml

@@ -8,17 +8,18 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        ruby: [2.6, 2.7, 3.0]
+        ruby: [2.7, 3.0, 3.1, 3.2]
 
     name: >-
       ${{matrix.os}}, ${{matrix.ruby}}
 
     runs-on: ${{matrix.os}}
     steps:
-    - uses: actions/checkout@v1
-    - uses: actions/setup-ruby@v1
+    - uses: actions/checkout@v3
+    - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{matrix.ruby}}
+        bundler-cache: true
     - name: Install dependencies
       run: |
         gem install bundler

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.6 2023-01-05
+
+- Add documentation
+- Implement `H1P.send_body_chunk`
+- Implement `H1P.send_chunked_response`
+- Implement `H1P.send_response`
+
+## 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,14 +1,14 @@
 PATH
   remote: .
   specs:
-    h1p (0.4)
+    h1p (0.6)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    minitest (5.14.4)
+    minitest (5.17.0)
     rake (13.0.6)
-    rake-compiler (1.1.1)
+    rake-compiler (1.2.1)
       rake
 
 PLATFORMS
@@ -16,9 +16,9 @@ PLATFORMS
 
 DEPENDENCIES
   h1p!
-  minitest (~> 5.14.4)
+  minitest (~> 5.17.0)
   rake (~> 13.0.6)
-  rake-compiler (= 1.1.1)
+  rake-compiler (= 1.2.1)
 
 BUNDLED WITH
    2.2.26

data/README.md

@@ -1,4 +1,4 @@
-# H1P - a blocking HTTP/1 parser for Ruby
+# H1P - HTTP/1 tools for Ruby
 
 [![Gem Version](https://badge.fury.io/rb/h1p.svg)](http://rubygems.org/gems/h1p)
 [![H1P Test](https://github.com/digital-fabric/h1p/workflows/Tests/badge.svg)](https://github.com/digital-fabric/h1p/actions?query=workflow%3ATests)
@@ -14,9 +14,8 @@ The H1P was originally written as part of
 [Tipi](https://github.com/digital-fabric/tipi), a web server running on top of
 [Polyphony](https://github.com/digital-fabric/polyphony).
 
-> H1P is still a very young project and as such should be used with caution. It
-> has not undergone any significant conformance or security testing, and its API
-> is not yet stable.
+In addition to parsing, H1P offers APIs for formatting and writing HTTP/1
+requests and responses.
 
 ## Features
 
@@ -26,7 +25,11 @@ 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
+- Write HTTP requests and responses to any IO instance, with support for chunked
+  transfer encoding.
 
 ## Installing
 
@@ -161,6 +164,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
@@ -189,7 +222,54 @@ as they conform to one of two alternative interfaces:
   #=> {":method"=>"get", ":path"=>"/foo", ":protocol"=>"http/1.1", ":rx"=>21}
   ```
 
-## Design
+## Writing HTTP requests and responses
+
+H1P implements optimized methods for writing HTTP requests and responses to
+arbitrary IO instances. To write a response with or without a body, use
+`H1P.send_response(io, headers, body = nil)`:
+
+```ruby
+H1P.send_response(socket, { 'Some-Header' => 'header value'}, 'foobar')
+#=> "HTTP/1.1 200 OK\r\nSome-Header: header value\r\n\r\nfoobar"
+
+# The :protocol pseudo header sets the protocol in the status line:
+H1P.send_response(socket, { ':protocol' => 'HTTP/0.9' })
+#=> "HTTP/0.9 200 OK\r\n\r\n"
+
+# The :status pseudo header sets the response status:
+H1P.send_response(socket, { ':status' => '418 I\'m a teapot' })
+#=> "HTTP/1.1 418 I'm a teapot\r\n\r\n"
+```
+
+To send responses using chunked transfer encoding use
+`H1P.send_chunked_response(io, header, body = nil)`:
+
+```ruby
+H1P.send_chunked_response(socket, {}, "foobar")
+#=> "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n6\r\nfoobar\r\n0\r\n\r\n"
+```
+
+You can also call `H1P.send_chunked_response` with a block that provides the
+next chunk to send. The last chunk is signalled by returning `nil` from the
+block:
+
+```ruby
+IO.open('/path/to/file') do |f|
+  H1P.send_chunked_response(socket, {}) { f.read(CHUNK_SIZE) }
+end
+```
+
+To send individual chunks use `H1P.send_body_chunk`:
+
+```ruby
+H1P.send_body_chunk(socket, 'foo')
+#=> "3\r\nfoo\r\n"
+
+H1P.send_body_chunk(socket, nil)
+#=> "0\r\n\r\n"
+```
+
+## Parser Design
 
 The H1P parser design is based on the following principles:
 

data/ext/h1p/h1p.c

@@ -1,4 +1,3 @@
-#include "ruby.h"
 #include "h1p.h"
 
 // Security-related limits are defined in limits.rb and injected as
@@ -16,6 +15,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;
@@ -24,11 +26,15 @@ ID ID_read_method;
 ID ID_read;
 ID ID_readpartial;
 ID ID_to_i;
+ID ID_to_s;
 ID ID_upcase;
+ID ID_write;
+ID ID_write_method;
 
-static VALUE mPolyphony = Qnil;
 static VALUE cError;
 
+VALUE eArgumentError;
+
 VALUE NUM_max_headers_read_length;
 VALUE NUM_buffer_start;
 VALUE NUM_buffer_end;
@@ -36,27 +42,41 @@ VALUE NUM_buffer_end;
 VALUE STR_pseudo_method;
 VALUE STR_pseudo_path;
 VALUE STR_pseudo_protocol;
+VALUE STR_pseudo_protocol_default;
 VALUE STR_pseudo_rx;
 VALUE STR_pseudo_status;
+VALUE STR_pseudo_status_default;
 VALUE STR_pseudo_status_message;
 
 VALUE STR_chunked;
 VALUE STR_content_length;
+VALUE STR_content_length_capitalized;
 VALUE STR_transfer_encoding;
+VALUE STR_transfer_encoding_capitalized;
+
+VALUE STR_CRLF;
+VALUE STR_EMPTY_CHUNK;
 
 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 +135,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(void) {
+  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;
@@ -147,6 +176,12 @@ enum parser_mode parse_parser_mode(VALUE mode) {
   rb_raise(rb_eRuntimeError, "Invalid parser mode specified");
 }
 
+/* call-seq:
+ *   parser.initialize(io, mode)
+ *
+ * Initializes a new parser with the given IO instance and mode. Mode is either
+ * `:server` or `:client`.
+ */
 VALUE Parser_initialize(VALUE self, VALUE io, VALUE mode) {
   Parser_t *parser;
   GetParser(self, parser);
@@ -246,7 +281,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 +329,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;
@@ -671,6 +722,19 @@ eof:
   return 0;
 }
 
+/* call-seq: parser.parse_headers -> headers
+ *
+ * Parses headers from the associated IO instance, returning a hash mapping
+ * header keys to their respective values. Header keys are downcased and dashes
+ * are converted to underscores. The returned headers will also include the
+ * following pseudo-headers:
+ * 
+ * - `':protocol'` - the protocol as specified in the query line / status line
+ * - `':path'` - the query path (for HTTP requests)
+ * - `':method'` - the HTTP method (for HTTP requests)
+ * - `':status'` - the HTTP status (for HTTP responses)
+ * - `':rx'` - the total number of bytes read by the parser
+ */
 VALUE Parser_parse_headers(VALUE self) {
   Parser_t *parser;
   GetParser(self, parser);
@@ -705,7 +769,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 +818,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 +832,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 +900,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 +916,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 +988,69 @@ 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;
+  }
+  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,17 +1080,54 @@ 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);
 }
 
+/* call-seq: parser.read_body -> body
+ *
+ * Reads an HTTP request/response body from the associated IO instance.
+ */
 VALUE Parser_read_body(VALUE self) {
   return read_body(self, 1, 0);
 }
 
+/* call-seq: parser.read_body_chunk(buffered_only) -> chunk
+ *
+ * Reads a single body chunk (useful for chunked transfer encoding). If
+ * `buffered_only` is true, will only read from the underlying buffer, without
+ * reading from the associated IO instance.
+ */
 VALUE Parser_read_body_chunk(VALUE self, VALUE buffered_only) {
   return read_body(self, 0, buffered_only == Qtrue);
 }
 
+/* call-seq: parser.splice_body_to(dest)
+ *
+ * Splices the HTTP request/response body from the associated IO instance to
+ * `dest`.
+ */
+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;
+}
+
+/* call-seq: parser.complete?
+ *
+ * Returns true if a complete HTTP request/response has been read from the
+ * associated IO instance.
+ */
 VALUE Parser_complete_p(VALUE self) {
   Parser_t *parser;
   GetParser(self, parser);
@@ -952,7 +1138,212 @@ VALUE Parser_complete_p(VALUE self) {
   return parser->request_completed ? Qtrue : Qfalse;
 }
 
-void Init_H1P() {
+typedef struct send_response_ctx {
+  VALUE io;
+  VALUE buffer;
+  char *buffer_ptr;
+  unsigned int buffer_len;
+  unsigned int total_written;
+} send_response_ctx;
+
+#define MAX_RESPONSE_BUFFER_SIZE 65536
+
+void send_response_flush_buffer(send_response_ctx *ctx) {
+  if (!ctx->buffer_len) return;
+
+  rb_str_set_len(ctx->buffer, ctx->buffer_len);
+  VALUE written = rb_funcall(ctx->io, ID_write, 1, ctx->buffer);
+  ctx->total_written += NUM2INT(written);
+  
+  rb_str_set_len(ctx->buffer, 0);
+  ctx->buffer_len = 0;
+}
+
+void send_response_write_status_line(send_response_ctx *ctx, VALUE protocol, VALUE status) {
+  char *ptr = ctx->buffer_ptr;
+
+  unsigned int partlen = RSTRING_LEN(protocol);
+  memcpy(ptr, RSTRING_PTR(protocol), partlen);
+  ctx->buffer_len += partlen;
+  ptr[ctx->buffer_len] = ' ';
+  ctx->buffer_len++;
+
+  ptr += ctx->buffer_len;
+  partlen = RSTRING_LEN(status);
+  memcpy(ptr, RSTRING_PTR(status), partlen);
+  ptr[partlen] = '\r';
+  ptr[partlen + 1] = '\n';
+  ctx->buffer_len += partlen + 2;
+}
+
+int send_response_write_header(VALUE key, VALUE val, VALUE arg) {
+  if (TYPE(key) != T_STRING) key = rb_funcall(key, ID_to_s, 0);
+  char *keyptr = RSTRING_PTR(key);
+  if (RSTRING_LEN(key) < 1 || keyptr[0] == ':') return 0;
+
+  if (TYPE(val) != T_STRING) val = rb_funcall(val, ID_to_s, 0);
+  unsigned int keylen = RSTRING_LEN(key);
+  char *valptr = RSTRING_PTR(val);
+  unsigned int vallen = RSTRING_LEN(val);
+  send_response_ctx *ctx = (send_response_ctx *)arg;
+
+  if (ctx->buffer_len + keylen + vallen > (MAX_RESPONSE_BUFFER_SIZE - 8))
+    send_response_flush_buffer(ctx);
+  
+  char *ptr = ctx->buffer_ptr + ctx->buffer_len;
+  memcpy(ptr, keyptr, keylen);
+  ptr[keylen] = ':';
+  ptr[keylen + 1] = ' ';
+  ptr += keylen + 2;
+
+  memcpy(ptr, valptr, vallen);
+  ptr[vallen] = '\r';
+  ptr[vallen + 1] = '\n';
+  ctx->buffer_len += keylen + vallen + 4;
+
+  RB_GC_GUARD(key);
+  RB_GC_GUARD(val);
+  
+  return 0; // ST_CONTINUE
+}
+
+/* call-seq: H1P.send_response(io, headers, body = nil) -> total_written
+ *
+ * Sends an HTTP response with the given headers and body.
+ */
+VALUE H1P_send_response(int argc,VALUE *argv, VALUE self) {
+  if (argc < 2)
+    rb_raise(eArgumentError, "(wrong number of arguments (expected 2 or more))");
+
+  VALUE io = argv[0];
+  VALUE headers = argv[1];
+  VALUE body = argc >= 3 ? argv[2] : Qnil;
+  VALUE buffer = rb_str_new_literal("");
+  rb_str_modify_expand(buffer, MAX_RESPONSE_BUFFER_SIZE);
+  send_response_ctx ctx = {io, buffer, RSTRING_PTR(buffer), 0, 0};
+
+  char *bodyptr = 0;
+  unsigned int bodylen = 0;
+
+  VALUE protocol = rb_hash_aref(headers, STR_pseudo_protocol);
+  if (protocol == Qnil) protocol = STR_pseudo_protocol_default;
+  VALUE status = rb_hash_aref(headers, STR_pseudo_status);
+  if (status == Qnil) status = STR_pseudo_status_default;
+  send_response_write_status_line(&ctx, protocol, status);
+
+  if (body != Qnil) {
+    if (TYPE(body) != T_STRING) body = rb_funcall(body, ID_to_s, 0);
+
+    bodyptr = RSTRING_PTR(body);
+    bodylen = RSTRING_LEN(body);
+    rb_hash_aset(headers, STR_content_length_capitalized, INT2FIX(bodylen));
+  }
+
+  rb_hash_foreach(headers, send_response_write_header, (VALUE)&ctx);
+
+  char *endptr = ctx.buffer_ptr + ctx.buffer_len;
+  endptr[0] = '\r';
+  endptr[1] = '\n';
+  ctx.buffer_len += 2;
+
+  if (body != Qnil) {
+    while (bodylen > 0) {
+      unsigned int chunklen = bodylen;
+      if (chunklen > MAX_RESPONSE_BUFFER_SIZE) chunklen = MAX_RESPONSE_BUFFER_SIZE;
+      
+      if (ctx.buffer_len + chunklen > MAX_RESPONSE_BUFFER_SIZE)
+        send_response_flush_buffer(&ctx);
+
+      memcpy(ctx.buffer_ptr + ctx.buffer_len, bodyptr, chunklen);
+      ctx.buffer_len += chunklen;
+      bodyptr += chunklen;
+      bodylen -= chunklen;
+    }
+    RB_GC_GUARD(body);
+  }
+
+  send_response_flush_buffer(&ctx);
+
+  RB_GC_GUARD(buffer);
+
+  return INT2FIX(ctx.total_written);
+}
+
+/* call-seq: H1P.send_body_chunk(io, chunk) -> total_written
+ *
+ * Sends a body chunk using chunked transfer encoding.
+ */
+VALUE H1P_send_body_chunk(VALUE self, VALUE io, VALUE chunk) {
+  if (chunk != Qnil) {
+    if (TYPE(chunk) != T_STRING) chunk = rb_funcall(chunk, ID_to_s, 0);
+
+    VALUE len_string = rb_str_new_literal("");
+    rb_str_modify_expand(len_string, 16);
+    int len_string_len = sprintf(RSTRING_PTR(len_string), "%lx\r\n", RSTRING_LEN(chunk));
+    rb_str_set_len(len_string,len_string_len);
+
+    VALUE total_written = rb_funcall(io, ID_write, 3, len_string, chunk, STR_CRLF);
+
+    RB_GC_GUARD(len_string);
+    RB_GC_GUARD(chunk);
+    return total_written;
+  }
+  else {
+    return rb_funcall(io, ID_write, 1, STR_EMPTY_CHUNK);
+  }
+}
+
+/* call-seq: H1P.send_chunked_response(io, headers, body = nil) -> total_written
+ *
+ * Sends an HTTP response with the given headers and body using chunked transfer
+ * encoding.
+ */
+VALUE H1P_send_chunked_response(VALUE self, VALUE io, VALUE headers) {
+  VALUE buffer = rb_str_new_literal("");
+  rb_str_modify_expand(buffer, MAX_RESPONSE_BUFFER_SIZE);
+  send_response_ctx ctx = {io, buffer, RSTRING_PTR(buffer), 0, 0};
+
+  VALUE protocol = rb_hash_aref(headers, STR_pseudo_protocol);
+  if (protocol == Qnil) protocol = STR_pseudo_protocol_default;
+  VALUE status = rb_hash_aref(headers, STR_pseudo_status);
+  if (status == Qnil) status = STR_pseudo_status_default;
+  send_response_write_status_line(&ctx, protocol, status);
+
+  rb_hash_aset(headers, STR_transfer_encoding_capitalized, STR_chunked);
+  rb_hash_foreach(headers, send_response_write_header, (VALUE)&ctx);
+
+  ctx.buffer_ptr[ctx.buffer_len] = '\r';
+  ctx.buffer_ptr[ctx.buffer_len + 1] = '\n';
+  ctx.buffer_len += 2;
+  send_response_flush_buffer(&ctx);
+
+  VALUE len_string = rb_str_new_literal("");
+  rb_str_modify_expand(len_string, 16);
+  while (1) {
+    VALUE chunk = rb_yield(Qnil);
+    if (chunk == Qnil) {
+      VALUE written = rb_funcall(io, ID_write, 1, STR_EMPTY_CHUNK);
+      ctx.total_written += NUM2INT(written);
+      break;
+    }
+    else {
+      if (TYPE(chunk) != T_STRING) chunk = rb_funcall(chunk, ID_to_s, 0);
+
+      int len_string_len = sprintf(RSTRING_PTR(len_string), "%lx\r\n", RSTRING_LEN(chunk));
+      rb_str_set_len(len_string,len_string_len);
+      VALUE written = rb_funcall(io, ID_write, 3, len_string, chunk, STR_CRLF);
+      ctx.total_written += NUM2INT(written);
+    }
+    RB_GC_GUARD(chunk);
+  }
+
+  RB_GC_GUARD(len_string);
+  RB_GC_GUARD(buffer);
+
+  return INT2FIX(ctx.total_written);
+}
+
+void Init_H1P(void) {
   VALUE mH1P;
   VALUE cParser;
 
@@ -964,51 +1355,73 @@ void Init_H1P() {
   cError = rb_define_class_under(mH1P, "Error", rb_eRuntimeError);
   rb_gc_register_mark_object(cError);
 
-  // backend methods
   rb_define_method(cParser, "initialize", Parser_initialize, 2);
   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);
 
+  rb_define_singleton_method(mH1P, "send_response", H1P_send_response, -1);
+  rb_define_singleton_method(mH1P, "send_body_chunk", H1P_send_body_chunk, 2);
+  rb_define_singleton_method(mH1P, "send_chunked_response", H1P_send_chunked_response, 2);
+
   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_to_s                   = rb_intern("to_s");
   ID_upcase                 = rb_intern("upcase");
+  ID_write                  = rb_intern("write");
+  ID_write_method           = rb_intern("__write_method__");
+
+  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");
+  GLOBAL_STR(STR_pseudo_protocol,             ":protocol");
+  GLOBAL_STR(STR_pseudo_protocol_default,     "HTTP/1.1");
+  GLOBAL_STR(STR_pseudo_rx,                   ":rx");
+  GLOBAL_STR(STR_pseudo_status,               ":status");
+  GLOBAL_STR(STR_pseudo_status_default,       "200 OK");
+  GLOBAL_STR(STR_pseudo_status_message,       ":status_message");
+
+  GLOBAL_STR(STR_chunked,                       "chunked");
+  GLOBAL_STR(STR_content_length,                "content-length");
+  GLOBAL_STR(STR_content_length_capitalized,    "Content-Length");
+  GLOBAL_STR(STR_transfer_encoding,             "transfer-encoding");
+  GLOBAL_STR(STR_transfer_encoding_capitalized, "Transfer-Encoding");
+
+  GLOBAL_STR(STR_CRLF,                        "\r\n");
+  GLOBAL_STR(STR_EMPTY_CHUNK,                 "0\r\n\r\n");
+
+  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);
 
-  NUM_max_headers_read_length = INT2NUM(MAX_HEADERS_READ_LENGTH);
-  NUM_buffer_start = INT2NUM(0);
-  NUM_buffer_end = INT2NUM(-1);
-
-  GLOBAL_STR(STR_pseudo_method,         ":method");
-  GLOBAL_STR(STR_pseudo_path,           ":path");
-  GLOBAL_STR(STR_pseudo_protocol,       ":protocol");
-  GLOBAL_STR(STR_pseudo_rx,             ":rx");
-  GLOBAL_STR(STR_pseudo_status,         ":status");
-  GLOBAL_STR(STR_pseudo_status_message, ":status_message");
-
-  GLOBAL_STR(STR_chunked,               "chunked");
-  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_stock_readpartial = ID2SYM(rb_intern("stock_readpartial"));
   
   SYM_client = ID2SYM(rb_intern("client"));
   SYM_server = ID2SYM(rb_intern("server"));
 
   rb_global_variable(&mH1P);
+
+  eArgumentError = rb_const_get(rb_cObject, rb_intern("ArgumentError"));
 }
 
-void Init_h1p_ext() {
+void Init_h1p_ext(void) {
   Init_H1P();
 }

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/h1p.gemspec

@@ -16,9 +16,9 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = ["README.md"]
   s.extensions = ["ext/h1p/extconf.rb"]
   s.require_paths = ["lib"]
-  s.required_ruby_version = '>= 2.6'
+  s.required_ruby_version = '>= 2.7'
 
-  s.add_development_dependency  'rake-compiler',        '1.1.1'
+  s.add_development_dependency  'rake-compiler',        '1.2.1'
   s.add_development_dependency  'rake',               '~>13.0.6'
-  s.add_development_dependency  'minitest',           '~>5.14.4'
+  s.add_development_dependency  'minitest',           '~>5.17.0'
 end

data/lib/h1p/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module H1P
-  VERSION = '0.4'
+  VERSION = '0.6'
 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/helper.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-
 require 'fileutils'
-
 require 'minitest/autorun'
 
 module Minitest::Assertions

data/test/test_h1p.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'h1p'
+
+class SendResponseTest < MiniTest::Test
+  def test_send_response_status_line
+    i, o = IO.pipe
+    H1P.send_response(o, { ':status' => '418 I\'m a teapot' })
+    o.close
+    response = i.read
+    assert_equal "HTTP/1.1 418 I'm a teapot\r\n\r\n", response
+
+    i, o = IO.pipe
+    count = H1P.send_response(o, { ':protocol' => 'HTTP/1.0' })
+    o.close
+    response = i.read
+    assert_equal "HTTP/1.0 200 OK\r\n\r\n", response
+    assert_equal "HTTP/1.0 200 OK\r\n\r\n".bytesize, count
+  end
+
+  def test_send_response_string_headers
+    i, o = IO.pipe
+    H1P.send_response(o, { 'Foo' => 'Bar', 'Content-Length' => '123' })
+    o.close
+    response = i.read
+    assert_equal "HTTP/1.1 200 OK\r\nFoo: Bar\r\nContent-Length: 123\r\n\r\n", response
+  end
+
+  def test_send_response_non_string_headers
+    i, o = IO.pipe
+    H1P.send_response(o, { :Foo => 'Bar', 'Content-Length' => 123 })
+    o.close
+    response = i.read
+    assert_equal "HTTP/1.1 200 OK\r\nFoo: Bar\r\nContent-Length: 123\r\n\r\n", response
+  end
+
+  def test_send_response_with_body
+    i, o = IO.pipe
+    H1P.send_response(o, {}, "foobar")
+    o.close
+    response = i.read
+    assert_equal "HTTP/1.1 200 OK\r\nContent-Length: 6\r\n\r\nfoobar", response
+  end
+
+  def test_send_response_with_big_body
+    i, o = IO.pipe
+    body = "abcdefg" * 10000
+    Thread.new { H1P.send_response(o, {}, body); o.close }
+
+    response = i.read
+    assert_equal "HTTP/1.1 200 OK\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}", response
+  end
+
+  def test_send_response_with_big_body
+    i, o = IO.pipe
+    body = "abcdefg" * 10000
+    Thread.new { H1P.send_response(o, {}, body); o.close }
+
+    response = i.read
+    assert_equal "HTTP/1.1 200 OK\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}", response
+  end
+end
+
+class SendBodyChunkTest < MiniTest::Test
+  def test_send_body_chunk
+    i, o = IO.pipe
+    len1 = H1P.send_body_chunk(o, 'foo')
+    assert_equal 8, len1
+    len2 = H1P.send_body_chunk(o, :barbazbarbaz)
+    assert_equal 17, len2
+    len3 = H1P.send_body_chunk(o, 1234)
+    assert_equal 9, len3
+    len4 = H1P.send_body_chunk(o, nil)
+    assert_equal 5, len4
+    o.close
+    response = i.read
+    assert_equal "3\r\nfoo\r\nc\r\nbarbazbarbaz\r\n4\r\n1234\r\n0\r\n\r\n", response
+  end
+
+  def test_send_body_chunk_big
+    i, o = IO.pipe
+
+    chunk = 'foobar1' * 20000
+    len = nil
+
+    Thread.new do
+      len = H1P.send_body_chunk(o, chunk)
+      o.close
+    end
+    
+    response = i.read
+    assert_equal "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n", response
+    assert_equal chunk.bytesize + chunk.bytesize.to_s(16).bytesize + 4, len
+  end
+end
+
+class SendChunkedResponseTest < MiniTest::Test
+  def test_send_chunked_response
+    isrc, osrc = IO.pipe
+    osrc << 'foobarbaz'
+    osrc.close
+
+    i, o = IO.pipe
+    len = H1P.send_chunked_response(o, { 'Foo' => 'bar' }) do
+      isrc.read(3)
+    end
+    o.close
+
+    response = i.read
+    assert_equal "HTTP/1.1 200 OK\r\nFoo: bar\r\nTransfer-Encoding: chunked\r\n\r\n3\r\nfoo\r\n3\r\nbar\r\n3\r\nbaz\r\n0\r\n\r\n", response
+    assert_equal len, response.bytesize
+  end
+end

data/test/test_h1p_server.rb

@@ -4,8 +4,9 @@ require_relative 'helper'
 require 'h1p'
 require 'socket'
 require_relative '../ext/h1p/limits'
+require 'securerandom'
 
-class H1PRequestTest < MiniTest::Test
+class H1PServerTest < MiniTest::Test
   Error = H1P::Error
 
   def setup
@@ -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.6'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-28 00:00:00.000000000 Z
+date: 2023-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: 1.2.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: 1.2.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.14.4
+        version: 5.17.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.14.4
+        version: 5.17.0
 description: 
 email: sharon@noteflakes.com
 executables: []
@@ -82,6 +82,7 @@ files:
 - lib/h1p/version.rb
 - test/helper.rb
 - test/run.rb
+- test/test_h1p.rb
 - test/test_h1p_client.rb
 - test/test_h1p_server.rb
 homepage: http://github.com/digital-fabric/h1p
@@ -101,14 +102,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.1
 signing_key: 
 specification_version: 4
 summary: H1P is a blocking HTTP/1 parser for Ruby