noderb-http 0.0.1

data/ext/noderb_http_extension/http_parser.h

@@ -0,0 +1,194 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+#ifndef http_parser_h
+#define http_parser_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define HTTP_PARSER_VERSION_MAJOR 1
+#define HTTP_PARSER_VERSION_MINOR 0
+
+#include <sys/types.h>
+#if defined(_WIN32) && !defined(__MINGW32__)
+typedef __int8 int8_t;
+typedef unsigned __int8 uint8_t;
+typedef __int16 int16_t;
+typedef unsigned __int16 uint16_t;
+typedef __int32 int32_t;
+typedef unsigned __int32 uint32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+
+typedef unsigned int size_t;
+typedef int ssize_t;
+#else
+#include <stdint.h>
+#endif
+
+/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run
+ * faster
+ */
+#ifndef HTTP_PARSER_STRICT
+# define HTTP_PARSER_STRICT 1
+#endif
+
+
+/* Maximium header size allowed */
+#define HTTP_MAX_HEADER_SIZE (80*1024)
+
+
+typedef struct http_parser http_parser;
+typedef struct http_parser_settings http_parser_settings;
+
+
+/* Callbacks should return non-zero to indicate an error. The parser will
+ * then halt execution.
+ *
+ * The one exception is on_headers_complete. In a HTTP_RESPONSE parser
+ * returning '1' from on_headers_complete will tell the parser that it
+ * should not expect a body. This is used when receiving a response to a
+ * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding:
+ * chunked' headers that indicate the presence of a body.
+ *
+ * http_data_cb does not return data chunks. It will be call arbitrarally
+ * many times for each string. E.G. you might get 10 callbacks for "on_path"
+ * each providing just a few characters more data.
+ */
+typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);
+typedef int (*http_cb) (http_parser*);
+
+
+/* Request Methods */
+enum http_method
+  { HTTP_DELETE    = 0
+  , HTTP_GET
+  , HTTP_HEAD
+  , HTTP_POST
+  , HTTP_PUT
+  /* pathological */
+  , HTTP_CONNECT
+  , HTTP_OPTIONS
+  , HTTP_TRACE
+  /* webdav */
+  , HTTP_COPY
+  , HTTP_LOCK
+  , HTTP_MKCOL
+  , HTTP_MOVE
+  , HTTP_PROPFIND
+  , HTTP_PROPPATCH
+  , HTTP_UNLOCK
+  /* subversion */
+  , HTTP_REPORT
+  , HTTP_MKACTIVITY
+  , HTTP_CHECKOUT
+  , HTTP_MERGE
+  /* upnp */
+  , HTTP_MSEARCH
+  , HTTP_NOTIFY
+  , HTTP_SUBSCRIBE
+  , HTTP_UNSUBSCRIBE
+  /* RFC-5789 */
+  , HTTP_PATCH
+  };
+
+
+enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH };
+
+
+/* Flag values for http_parser.flags field */
+enum flags
+  { F_CHUNKED               = 1 << 0
+  , F_CONNECTION_KEEP_ALIVE = 1 << 1
+  , F_CONNECTION_CLOSE      = 1 << 2
+  , F_TRAILING              = 1 << 3
+  , F_UPGRADE               = 1 << 4
+  , F_SKIPBODY              = 1 << 5
+  };
+
+
+struct http_parser {
+  /** PRIVATE **/
+  unsigned char type : 2;
+  unsigned char flags : 6; /* F_* values from 'flags' enum; semi-public */
+  unsigned char state;
+  unsigned char header_state;
+  unsigned char index;
+
+  uint32_t nread;
+  int64_t content_length;
+
+  /** READ-ONLY **/
+  unsigned short http_major;
+  unsigned short http_minor;
+  unsigned short status_code; /* responses only */
+  unsigned char method;    /* requests only */
+
+  /* 1 = Upgrade header was present and the parser has exited because of that.
+   * 0 = No upgrade header present.
+   * Should be checked when http_parser_execute() returns in addition to
+   * error checking.
+   */
+  char upgrade;
+
+  /** PUBLIC **/
+  void *data; /* A pointer to get hook to the "connection" or "socket" object */
+};
+
+
+struct http_parser_settings {
+  http_cb      on_message_begin;
+  http_data_cb on_path;
+  http_data_cb on_query_string;
+  http_data_cb on_url;
+  http_data_cb on_fragment;
+  http_data_cb on_header_field;
+  http_data_cb on_header_value;
+  http_cb      on_headers_complete;
+  http_data_cb on_body;
+  http_cb      on_message_complete;
+};
+
+
+void http_parser_init(http_parser *parser, enum http_parser_type type);
+
+
+size_t http_parser_execute(http_parser *parser,
+                           const http_parser_settings *settings,
+                           const char *data,
+                           size_t len);
+
+
+/* If http_should_keep_alive() in the on_headers_complete or
+ * on_message_complete callback returns true, then this will be should be
+ * the last message on the connection.
+ * If you are the server, respond with the "Connection: close" header.
+ * If you are the client, close the connection.
+ */
+int http_should_keep_alive(http_parser *parser);
+
+/* Returns a string version of the HTTP method. */
+const char *http_method_str(enum http_method);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/noderb_http_extension/noderb_http.c

@@ -0,0 +1,165 @@
+#include <noderb_http.h>
+
+typedef struct {
+    long parser;
+} nodeRb_http;
+
+VALUE nodeRbHttpParser;
+
+VALUE nodeRb_get_object_from_id(long id) {
+    return rb_funcall(rb_const_get(rb_cObject, rb_intern("ObjectSpace")), rb_intern("_id2ref"), 1, rb_int2inum(id));
+}
+
+int nodeRb_http_on_message_begin(http_parser* parser) {
+    nodeRb_http* client = parser->data;
+    VALUE self = nodeRb_get_object_from_id(client->parser);
+    rb_funcall(self, rb_intern("on_message_begin"), 0);
+    return 0;
+}
+
+int nodeRb_http_on_message_complete(http_parser* parser) {
+    nodeRb_http* client = parser->data;
+    VALUE self = nodeRb_get_object_from_id(client->parser);
+    if (http_should_keep_alive(parser)) {
+        rb_funcall(self, rb_intern("on_close_keep_alive"), 0);
+    };
+    rb_funcall(self, rb_intern("on_message_complete"), 0);
+    return 0;
+}
+
+int nodeRb_http_on_headers_complete(http_parser* parser) {
+    nodeRb_http* client = parser->data;
+    VALUE self = nodeRb_get_object_from_id(client->parser);
+    rb_funcall(self, rb_intern("on_headers_complete_internal"), 0);
+    return 0;
+}
+
+int nodeRb_http_on_header_field(http_parser* parser, const char *buf, size_t len) {
+    nodeRb_http* client = parser->data;
+    VALUE self = nodeRb_get_object_from_id(client->parser);
+    rb_funcall(self, rb_intern("on_header_field_internal"), 1, rb_str_new(buf, len));
+    return 0;
+}
+
+int nodeRb_http_on_header_value(http_parser* parser, const char *buf, size_t len) {
+    nodeRb_http* client = parser->data;
+    VALUE self = nodeRb_get_object_from_id(client->parser);
+    rb_funcall(self, rb_intern("on_header_value_internal"), 1, rb_str_new(buf, len));
+    return 0;
+}
+
+int nodeRb_http_on_path(http_parser* parser, const char *buf, size_t len) {
+    nodeRb_http* client = parser->data;
+    VALUE self = nodeRb_get_object_from_id(client->parser);
+    rb_funcall(self, rb_intern("on_method"), 1, rb_str_new2(http_method_str(parser->method)));
+    rb_funcall(self, rb_intern("on_path"), 1, rb_str_new(buf, len));
+    return 0;
+}
+
+int nodeRb_http_on_query_string(http_parser* parser, const char *buf, size_t len) {
+    nodeRb_http* client = parser->data;
+    VALUE self = nodeRb_get_object_from_id(client->parser);
+    rb_funcall(self, rb_intern("on_query_string"), 1, rb_str_new(buf, len));
+    return 0;
+}
+
+int nodeRb_http_on_url(http_parser* parser, const char *buf, size_t len) {
+    nodeRb_http* client = parser->data;
+    VALUE self = nodeRb_get_object_from_id(client->parser);
+    rb_funcall(self, rb_intern("on_url"), 1, rb_str_new(buf, len));
+    return 0;
+}
+
+int nodeRb_http_on_fragment(http_parser* parser, const char *buf, size_t len) {
+    nodeRb_http* client = parser->data;
+    VALUE self = nodeRb_get_object_from_id(client->parser);
+    rb_funcall(self, rb_intern("on_fragment"), 1, rb_str_new(buf, len));
+    return 0;
+}
+
+int nodeRb_http_on_body(http_parser* parser, const char *buf, size_t len) {
+    nodeRb_http* client = parser->data;
+    VALUE self = nodeRb_get_object_from_id(client->parser);
+    rb_funcall(self, rb_intern("on_body"), 1, rb_str_new(buf, len));
+    return 0;
+}
+
+VALUE nodeRb_http_setup(VALUE self) {
+    http_parser_settings* settings = malloc(sizeof (http_parser_settings));
+
+    settings->on_message_begin = nodeRb_http_on_message_begin;
+    settings->on_message_complete = nodeRb_http_on_message_complete;
+    settings->on_headers_complete = nodeRb_http_on_headers_complete;
+
+    settings->on_path = nodeRb_http_on_path;
+    settings->on_query_string = nodeRb_http_on_query_string;
+    settings->on_url = nodeRb_http_on_url;
+
+    settings->on_header_field = nodeRb_http_on_header_field;
+    settings->on_header_value = nodeRb_http_on_header_value;
+
+    settings->on_fragment = nodeRb_http_on_fragment;
+    settings->on_body = nodeRb_http_on_body;
+
+
+    http_parser* parser = malloc(sizeof (http_parser));
+    http_parser_init(parser, HTTP_REQUEST);
+
+    nodeRb_http* client = malloc(sizeof (nodeRb_http));
+    parser->data = client;
+
+    client->parser = rb_num2long(rb_obj_id(self));
+
+    rb_iv_set(self, "@settings", Data_Wrap_Struct(nodeRbHttpParser, 0, NULL, settings));
+    rb_iv_set(self, "@parser", Data_Wrap_Struct(nodeRbHttpParser, 0, NULL, parser));
+};
+
+VALUE nodeRb_http_parse(VALUE self, VALUE data) {
+
+    http_parser_settings* settings;
+    http_parser* parser;
+
+    VALUE rsettings = rb_iv_get(self, "@settings");
+    VALUE rparser = rb_iv_get(self, "@parser");
+
+
+    Data_Get_Struct(rsettings, http_parser_settings, settings);
+    Data_Get_Struct(rparser, http_parser, parser);
+
+    nodeRb_http* client = parser->data;
+
+    size_t parsed = http_parser_execute(parser, settings, rb_string_value_cstr(&data), RSTRING_LEN(data));
+
+    if (parser->upgrade) {
+        rb_funcall(self, rb_intern("on_upgrade"), 0);
+    } else if (parsed != RSTRING_LEN(data)) {
+        rb_funcall(self, rb_intern("on_error"), 0);
+    };
+};
+
+VALUE nodeRb_http_dispose(VALUE self) {
+    http_parser_settings* settings;
+    http_parser* parser;
+
+    Data_Get_Struct(rb_iv_get(self, "@settings"), http_parser_settings, settings);
+    Data_Get_Struct(rb_iv_get(self, "@parser"), http_parser, parser);
+
+    free(parser->data);
+    free(settings);
+    free(parser);
+};
+
+void Init_noderb_http() {
+    // Define module
+    VALUE nodeRb = rb_define_module("NodeRb");
+    // Modules
+    VALUE nodeRbModules = rb_define_module_under(nodeRb, "Modules");
+    // Http
+    VALUE nodeRbHttp = rb_define_module_under(nodeRbModules, "Http");
+    // Http parser
+    nodeRbHttpParser = rb_define_class_under(nodeRbHttp, "Parser", rb_cObject);
+    // Methods
+    rb_define_method(nodeRbHttpParser, "setup", nodeRb_http_setup, 0);
+    rb_define_method(nodeRbHttpParser, "parse", nodeRb_http_parse, 1);
+    rb_define_method(nodeRbHttpParser, "dispose", nodeRb_http_dispose, 0);
+}

data/ext/noderb_http_extension/noderb_http.h

@@ -0,0 +1,2 @@
+#include <http_parser.h>
+#include <ruby.h>

data/lib/noderb/modules/http.rb

@@ -0,0 +1,99 @@
+module NodeRb
+  module Modules
+    module Http
+
+      module Rack
+
+        def initialize
+          @env = {}
+        end
+
+        def on_header name, value
+        end
+
+      end
+
+      class Parser
+
+        def on_message_begin
+        end
+
+        def on_method method
+        end
+
+        def on_path path
+        end
+
+        def on_query_string query_string
+        end
+
+        def on_url url
+        end
+
+        def on_fragment fragment
+        end
+
+        def on_header_field_internal name
+          if @_header_state == :value
+            on_header_value(@_header_value)
+            on_header(@_header_name, @_header_value)
+            @_header_name = nil
+            @_header_value = nil
+          end
+          @_header_state = :field
+          @_header_name ||= ""
+          @_header_name << name
+        end
+
+        def on_header_field name
+          
+        end
+
+        def on_header_value_internal value
+          if @_header_state == :field
+            on_header_field(@_header_name)
+          end
+          @_header_state = :value
+          @_header_value ||= ""
+          @_header_value << value
+        end
+
+        def on_header_value value
+
+        end
+
+        def on_header name, value
+        end
+
+        def on_headers_complete_internal
+          on_header_value(@_header_value)
+          on_header(@_header_name, @_header_value)
+          @_header_name = nil
+          @_header_value = nil
+          on_headers_complete
+        end
+
+        def on_headers_complete
+          
+        end
+
+        def on_close_keep_alive
+        end
+
+        def on_upgrade
+        end
+
+        def on_body body
+        end
+
+        def on_message_complete
+        end
+
+        def on_error
+        end
+
+      end
+
+    end
+  end
+end

data/lib/noderb-http.rb

@@ -0,0 +1,2 @@
+require 'noderb_http_extension/noderb_http'
+require "noderb/modules/http"

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: noderb-http
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Marek Jelen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-24 00:00:00.000000000Z
+dependencies: []
+description: Fast and full-featured HTTP parser.
+email:
+- marek@jelen.biz
+executables: []
+extensions:
+- ext/noderb_http_extension/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/noderb/modules/http.rb
+- lib/noderb-http.rb
+- ext/http_parser.o
+- ext/noderb_http.o
+- ext/noderb_http_extension/extconf.rb
+- ext/noderb_http_extension/http_parser.c
+- ext/noderb_http_extension/http_parser.h
+- ext/noderb_http_extension/noderb_http.c
+- ext/noderb_http_extension/noderb_http.h
+- LICENSE
+- README.md
+homepage: http://github.com/noderb/noderb-http
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Fast and full-featured HTTP parser
+test_files: []