mizu 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd610e46c078a3e1c24113b369ea341fe0cd338171ed8f0ecf2a425cd4ba1eb6
-  data.tar.gz: 69026e1dab931e90d3533a91624a4a0f39d06c602cf930c00df1f94010304586
+  metadata.gz: f384f4dbe7507bfef6161da9de278370dd4a125de35b0ac8ffd625b65a7cef8d
+  data.tar.gz: c28c5ef22449faf141d1df141318e0207fa78c9d9cd7bea4002f1cd057f1fd86
 SHA512:
-  metadata.gz: 2d16f63e8b7ff4def6bc23a76d7c7d45cf8df978d56320706d8d36fbeec5c59a0393e6c9087e6633d5a7d2ed18344949dce47edda14b2f996319df4cb57e89d7
-  data.tar.gz: 2b314fa76a45282f84753db1ef2034bb2cbfb1c95327cdb373e0c31ccc045afe69ab298692c961a38fed45b95bed513c2a79e444daff3aa23453e2d1a91590dc
+  metadata.gz: f841120450f173f28fabfe4ff7698fceff24f9d6d9053a18be3a84cca2a6352521096d1dd07ae111daf45acfd3fc1096cf18bc172192838a0c4d4fe87a623a86
+  data.tar.gz: 2f0be48674a6620eb012a0ef708ca9256ca773b9ce045efca9195adc0b9205eb2e76c10694e72f1febcf3da352c29e233230fa50aaceb97fb10fba298d9485dc

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "ext/mizu/picohttpparser"]
+	path = ext/mizu/picohttpparser
+	url = git@github.com:h2o/picohttpparser.git

data/ext/mizu/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+extension_name = 'mizu_ext'
+dir_config(extension_name)
+create_makefile(extension_name)

data/ext/mizu/parser.c

@@ -0,0 +1,196 @@
+#include <ruby.h>
+#include "picohttpparser/picohttpparser.c"
+
+VALUE Mizu = Qnil;
+VALUE MizuExceptions = Qnil;
+VALUE MizuParser = Qnil;
+
+VALUE HeadersTooLongError = Qnil;
+VALUE ParseError = Qnil;
+
+void Init_mizu_ext();
+VALUE method_mizu_parser_alloc(VALUE klass);
+VALUE method_mizu_parser_reset(VALUE self);
+static void method_parser_mark(void *p);
+static void method_mizu_parser_free(void *p);
+VALUE method_mizu_parser_parse(VALUE self, VALUE data);
+VALUE method_mizu_parser_version(VALUE self);
+VALUE method_mizu_parser_offset(VALUE self);
+VALUE method_mizu_parser_headers(VALUE self);
+VALUE method_mizu_parser_method(VALUE self);
+VALUE method_mizu_parser_path(VALUE self);
+ID id_call;
+
+typedef struct
+{
+  char _buf[4096];
+  const char *_method;
+  const char *_path;
+  struct phr_header _headers[128];
+  size_t _buflen;
+  size_t _prevbuflen;
+  size_t _method_len;
+  size_t _path_len;
+  size_t _num_headers;
+  int _pret;
+  int _minor_version;
+  VALUE version;
+  VALUE offset;
+  VALUE headers;
+  VALUE method;
+  VALUE path;
+} ParserWrapper;
+
+void Init_mizu_ext()
+{
+  Mizu = rb_define_module("Mizu");
+  MizuExceptions = rb_define_class_under(Mizu, "Exceptions", rb_cObject);
+  MizuParser = rb_define_class_under(Mizu, "Parser", rb_cObject);
+  HeadersTooLongError = rb_const_get(MizuExceptions, rb_intern("HeadersTooLongError"));
+  ParseError = rb_const_get(MizuExceptions, rb_intern("ParseError"));
+  rb_define_alloc_func(MizuParser, method_mizu_parser_alloc);
+  rb_define_method(MizuParser, "<<", method_mizu_parser_parse, 1);
+  rb_define_method(MizuParser, "reset!", method_mizu_parser_reset, 0);
+  rb_define_method(MizuParser, "version", method_mizu_parser_version, 0);
+  rb_define_method(MizuParser, "offset", method_mizu_parser_offset, 0);
+  rb_define_method(MizuParser, "headers", method_mizu_parser_headers, 0);
+  rb_define_method(MizuParser, "method", method_mizu_parser_method, 0);
+  rb_define_method(MizuParser, "path", method_mizu_parser_path, 0);
+  id_call = rb_intern("call");
+}
+
+VALUE method_mizu_parser_alloc(VALUE klass)
+{
+  ParserWrapper *ptr = ALLOC(ParserWrapper);
+  ptr->_buflen = 0;
+  ptr->_prevbuflen = 0;
+  return Data_Wrap_Struct(klass, method_parser_mark, method_mizu_parser_free, ptr);
+}
+
+VALUE method_mizu_parser_reset(VALUE self)
+{
+  ParserWrapper *wrapper;
+  Data_Get_Struct(self, ParserWrapper, wrapper);
+  wrapper->_buflen = 0;
+  wrapper->_prevbuflen = 0;
+  return Qnil;
+}
+
+static void method_parser_mark(void *p)
+{
+  if (p)
+  {
+    ParserWrapper *wrapper = (ParserWrapper *)p;
+    rb_gc_mark_maybe(wrapper->version);
+    rb_gc_mark_maybe(wrapper->offset);
+    rb_gc_mark_maybe(wrapper->headers);
+    rb_gc_mark_maybe(wrapper->method);
+    rb_gc_mark_maybe(wrapper->path);
+  }
+}
+
+static void method_mizu_parser_free(void *p)
+{
+  xfree(p);
+}
+
+VALUE method_mizu_parser_parse(VALUE self, VALUE data)
+{
+  ParserWrapper *wrapper;
+  Data_Get_Struct(self, ParserWrapper, wrapper);
+  char *buffer = StringValueCStr(data);
+  ssize_t rret = strlen(buffer);
+  if (wrapper->_buflen + rret >= sizeof(wrapper->_buf))
+  {
+    rb_raise(HeadersTooLongError, "Request Headers Too Long");
+  }
+  memcpy(wrapper->_buf + wrapper->_buflen, buffer, rret);
+  wrapper->_prevbuflen = wrapper->_buflen;
+  wrapper->_buflen += rret;
+  wrapper->_num_headers = sizeof(wrapper->_headers) / sizeof(wrapper->_headers[0]);
+  wrapper->_pret = phr_parse_request(
+      wrapper->_buf,
+      wrapper->_buflen,
+      &(wrapper->_method),
+      &(wrapper->_method_len),
+      &(wrapper->_path),
+      &(wrapper->_path_len),
+      &(wrapper->_minor_version),
+      wrapper->_headers,
+      &(wrapper->_num_headers),
+      wrapper->_prevbuflen);
+
+  if (wrapper->_pret > 0)
+  {
+    // Parsed
+    size_t i;
+    ParserWrapper *wrapper;
+    Data_Get_Struct(self, ParserWrapper, wrapper);
+    VALUE headers;
+
+    wrapper->offset = ULONG2NUM(wrapper->_pret - wrapper->_prevbuflen);
+    wrapper->version = rb_sprintf("1.%d", wrapper->_minor_version);
+    wrapper->method = rb_str_new(wrapper->_method, wrapper->_method_len);
+    wrapper->path = rb_str_new(wrapper->_path, wrapper->_path_len);
+
+    headers = rb_hash_new();
+    for (i = 0; i < wrapper->_num_headers; i++)
+    {
+      VALUE header_name = rb_str_new(wrapper->_headers[i].name, wrapper->_headers[i].name_len);
+      VALUE header_value = rb_str_new(wrapper->_headers[i].value, wrapper->_headers[i].value_len);
+      rb_hash_aset(headers, header_name, header_value);
+    }
+
+    wrapper->headers = headers;
+    rb_funcall(rb_iv_get(self, "@callback"), id_call, 0);
+  }
+  else if (wrapper->_pret == -1)
+  {
+    rb_raise(ParseError, "Illegal HTTP/1.x Request");
+  }
+  else if (wrapper->_pret == -2)
+  {
+    return Qnil; // Incomplete parsing, needs more data.
+  }
+
+  if (wrapper->_buflen == sizeof(wrapper->_buf))
+  {
+    rb_raise(HeadersTooLongError, "Request Headers Too Long");
+  }
+  return Qnil;
+}
+
+VALUE method_mizu_parser_version(VALUE self)
+{
+  ParserWrapper *p;
+  Data_Get_Struct(self, ParserWrapper, p);
+  return p->version;
+}
+
+VALUE method_mizu_parser_offset(VALUE self)
+{
+  ParserWrapper *p;
+  Data_Get_Struct(self, ParserWrapper, p);
+  return p->offset;
+}
+
+VALUE method_mizu_parser_headers(VALUE self)
+{
+  ParserWrapper *p;
+  Data_Get_Struct(self, ParserWrapper, p);
+  return p->headers;
+}
+
+VALUE method_mizu_parser_method(VALUE self)
+{
+  ParserWrapper *p;
+  Data_Get_Struct(self, ParserWrapper, p);
+  return p->method;
+}
+
+VALUE method_mizu_parser_path(VALUE self)
+{
+  ParserWrapper *p;
+  Data_Get_Struct(self, ParserWrapper, p);
+  return p->path;
+}

data/lib/mizu/exceptions.rb

@@ -0,0 +1,6 @@
+module Mizu
+  class Exceptions
+    class ParseError < IOError; end
+    class HeadersTooLongError < IOError; end
+  end
+end

data/lib/mizu/parser.rb

@@ -0,0 +1,7 @@
+module Mizu
+  class Parser
+    def on_complete(&block)
+      @callback = block
+    end
+  end
+end

data/lib/mizu/version.rb

@@ -0,0 +1,3 @@
+module Mizu
+  VERSION = '0.0.1'.freeze
+end

data/lib/mizu.rb

@@ -0,0 +1,4 @@
+require_relative './mizu/version.rb'
+require_relative './mizu/exceptions.rb'
+require_relative './mizu/parser.rb'
+require_relative 'mizu_ext'

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: mizu
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - HeckPsi Lab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-11 00:00:00.000000000 Z
-dependencies: []
+date: 2018-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Mizu is a Ruby port of h2o/picohttpparser, designed to be merged in next
   generation of midori.
 email:
@@ -18,7 +32,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitmodules"
 - LICENSE
+- ext/mizu/extconf.rb
+- ext/mizu/parser.c
+- lib/mizu.rb
+- lib/mizu/exceptions.rb
+- lib/mizu/parser.rb
+- lib/mizu/version.rb
 homepage: https://github.com/midori-rb/mizu
 licenses:
 - MIT