ruby_http_parser 0.0.1

data/ext/ruby_http_parser/ext_help.h

@@ -0,0 +1,18 @@
+#ifndef ext_help_h
+#define ext_help_h
+
+#define RAISE_NOT_NULL(T) if(T == NULL) rb_raise(rb_eArgError, "NULL found for " # T " when shouldn't be.");
+#define DATA_GET(from,type,name) Data_Get_Struct(from,type,name); RAISE_NOT_NULL(name);
+#define REQUIRE_TYPE(V, T) if(TYPE(V) != T) rb_raise(rb_eTypeError, "Wrong argument type for " # V " required " # T);
+
+/* for compatibility with Ruby 1.8.5, which doesn't declare RSTRING_PTR */
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+/* for compatibility with Ruby 1.8.5, which doesn't declare RSTRING_LEN */
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#endif

data/ext/ruby_http_parser/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+ 
+http_parser_dir = File.expand_path(File.dirname(__FILE__) + '/../http-parser')
+$CFLAGS << " -I#{http_parser_dir} "
+
+dir_config("ruby_http_parser")
+create_makefile("ruby_http_parser")

data/ext/ruby_http_parser/ruby_http_parser.c

@@ -0,0 +1,275 @@
+#include "ruby.h"
+#include "ext_help.h"
+#include "http_parser.c"
+
+#define HEADER_PREFIX         "HTTP_"
+#define DEF_CONST(N, val)     N = rb_obj_freeze(rb_str_new2(val)); rb_global_variable(&N)
+#define GET_WRAPPER(N, from)  ParserWrapper *N = (ParserWrapper *)(from)->data;
+
+#define HASH_CAT(h, k, ptr, len) \
+  do { \
+    VALUE __v = rb_hash_aref(h, k); \
+    if (__v != Qnil) { \
+      rb_str_cat(__v, ptr, len); \
+    } else { \
+      rb_hash_aset(h, k, rb_str_new(ptr, len)); \
+    } \
+  } while(0)
+
+
+// Stolen from Ebb
+static char upcase[] =
+  "\0______________________________"
+  "_________________0123456789_____"
+  "__ABCDEFGHIJKLMNOPQRSTUVWXYZ____"
+  "__ABCDEFGHIJKLMNOPQRSTUVWXYZ____"
+  "________________________________"
+  "________________________________"
+  "________________________________"
+  "________________________________";
+
+typedef struct ParserWrapper {
+  http_parser parser;
+  VALUE env;
+  VALUE on_message_complete;
+  VALUE on_headers_complete;
+  VALUE on_body;
+  VALUE last_field_name;
+  const char *last_field_name_at;
+  size_t last_field_name_length;
+} ParserWrapper;
+
+static VALUE eParserError;
+static VALUE sCall;
+static VALUE sPathInfo;
+static VALUE sQueryString;
+static VALUE sURL;
+static VALUE sFragment;
+
+/** Callbacks **/
+
+int on_message_begin(http_parser *parser) {
+  GET_WRAPPER(wrapper, parser);
+  // Init env Rack hash
+  if (wrapper->env != Qnil)
+    rb_gc_unregister_address(&wrapper->env);
+  wrapper->env = rb_hash_new();
+  rb_gc_register_address(&wrapper->env);
+  
+  return 0;
+}
+
+int on_path(http_parser *parser, const char *at, size_t length) {
+  GET_WRAPPER(wrapper, parser);
+  HASH_CAT(wrapper->env, sPathInfo, at, length);
+  return 0;
+}
+
+int on_query_string(http_parser *parser, const char *at, size_t length) {
+  GET_WRAPPER(wrapper, parser);
+  HASH_CAT(wrapper->env, sQueryString, at, length);
+  return 0;
+}
+
+int on_url(http_parser *parser, const char *at, size_t length) {
+  GET_WRAPPER(wrapper, parser);
+  HASH_CAT(wrapper->env, sURL, at, length);
+  return 0;
+}
+
+int on_fragment(http_parser *parser, const char *at, size_t length) {
+  GET_WRAPPER(wrapper, parser);
+  HASH_CAT(wrapper->env, sFragment, at, length);
+  return 0;
+}
+
+int on_header_field(http_parser *parser, const char *at, size_t length) {
+  GET_WRAPPER(wrapper, parser);
+  
+  wrapper->last_field_name = Qnil;
+  
+  if (wrapper->last_field_name_at == NULL) {
+    wrapper->last_field_name_at = at;
+    wrapper->last_field_name_length = length;
+  } else {
+    wrapper->last_field_name_length += length;
+  }
+  
+  return 0;
+}
+
+int on_header_value(http_parser *parser, const char *at, size_t length) {
+  GET_WRAPPER(wrapper, parser);
+  
+  VALUE name = Qnil;
+  
+  if (wrapper->last_field_name == Qnil) {
+    wrapper->last_field_name = rb_str_new(HEADER_PREFIX, sizeof(HEADER_PREFIX) - 1 + wrapper->last_field_name_length);
+    
+    // normalize header name
+    size_t name_length = wrapper->last_field_name_length;
+    const char *name_at = wrapper->last_field_name_at;
+    char *name_ptr = RSTRING_PTR(wrapper->last_field_name) + sizeof(HEADER_PREFIX) - 1;
+    int i;
+    for(i = 0; i < name_length; i++) {
+      char *ch = name_ptr + i;
+      *ch = upcase[(int)name_at[i]];
+    }
+    
+    wrapper->last_field_name_at = NULL;
+    wrapper->last_field_name_length = 0;
+  }
+  
+  HASH_CAT(wrapper->env, wrapper->last_field_name, at, length);
+  
+  return 0;
+}
+
+int on_headers_complete(http_parser *parser) {
+  GET_WRAPPER(wrapper, parser);
+  
+  if (wrapper->on_headers_complete != Qnil) {
+    rb_funcall(wrapper->on_headers_complete, sCall, 1, wrapper->env);
+  }
+  
+  return 0;
+}
+
+int on_body(http_parser *parser, const char *at, size_t length) {
+  GET_WRAPPER(wrapper, parser);
+  
+  if (wrapper->on_body != Qnil) {
+    rb_funcall(wrapper->on_body, sCall, 1, rb_str_new(at, length));
+  }
+  
+  return 0;
+}
+
+int on_message_complete(http_parser *parser) {
+  GET_WRAPPER(wrapper, parser);
+  
+  if (wrapper->on_message_complete != Qnil) {
+    rb_funcall(wrapper->on_message_complete, sCall, 1, wrapper->env);
+  }
+  
+  return 0;
+}
+
+
+/** Usual ruby C stuff **/
+
+void Parser_free(void *data) {
+  if(data) {
+    ParserWrapper *wrapper = (ParserWrapper *) data;
+    if (wrapper->env != Qnil)
+      rb_gc_unregister_address(&wrapper->env);
+    free(data);
+  }
+}
+
+VALUE Parser_alloc(VALUE klass) {
+  ParserWrapper *wrapper = ALLOC_N(ParserWrapper, 1);
+  http_parser_init(&wrapper->parser);
+  
+  wrapper->env = Qnil;
+  wrapper->on_message_complete = Qnil;
+  wrapper->on_headers_complete = Qnil;
+  wrapper->on_body = Qnil;
+  
+  wrapper->last_field_name = Qnil;
+  wrapper->last_field_name_at = NULL;
+  wrapper->last_field_name_length = 0;
+  
+  // Init callbacks
+  wrapper->parser.on_message_begin = on_message_begin;
+  wrapper->parser.on_path = on_path;
+  wrapper->parser.on_query_string = on_query_string;
+  wrapper->parser.on_url = on_url;
+  wrapper->parser.on_fragment = on_fragment;
+  wrapper->parser.on_header_field = on_header_field;
+  wrapper->parser.on_header_value = on_header_value;
+  wrapper->parser.on_headers_complete = on_headers_complete;
+  wrapper->parser.on_body = on_body;
+  wrapper->parser.on_message_complete = on_message_complete;
+  
+  wrapper->parser.data = wrapper;
+
+  return Data_Wrap_Struct(klass, NULL, Parser_free, wrapper);
+}
+
+VALUE Parser_parse_requests(VALUE self, VALUE data) {
+  ParserWrapper *wrapper = NULL;
+  char *ptr = RSTRING_PTR(data);
+  long len = RSTRING_LEN(data);
+  
+  DATA_GET(self, ParserWrapper, wrapper);
+  
+  size_t nparsed = http_parse_requests(&wrapper->parser, ptr, len);
+  
+  if (nparsed != len) {
+    rb_raise(eParserError, "Invalid request");
+  }
+}
+
+VALUE Parser_parse_responses(VALUE self, VALUE data) {
+  ParserWrapper *wrapper = NULL;
+  char *ptr = RSTRING_PTR(data);
+  long len = RSTRING_LEN(data);
+  
+  DATA_GET(self, ParserWrapper, wrapper);
+  
+  size_t nparsed = http_parse_responses(&wrapper->parser, ptr, len);
+  
+  if (nparsed != len) {
+    rb_raise(eParserError, "Invalid response");
+  }
+}
+
+VALUE Parser_set_on_headers_complete(VALUE self, VALUE callback) {
+  ParserWrapper *wrapper = NULL;
+  DATA_GET(self, ParserWrapper, wrapper);
+  
+  wrapper->on_headers_complete = callback;
+  return callback;
+}
+
+VALUE Parser_set_on_message_complete(VALUE self, VALUE callback) {
+  ParserWrapper *wrapper = NULL;
+  DATA_GET(self, ParserWrapper, wrapper);
+  
+  wrapper->on_message_complete = callback;
+  return callback;
+}
+
+VALUE Parser_set_on_body(VALUE self, VALUE callback) {
+  ParserWrapper *wrapper = NULL;
+  DATA_GET(self, ParserWrapper, wrapper);
+  
+  wrapper->on_body = callback;
+  return callback;
+}
+
+
+void Init_ruby_http_parser() {
+  VALUE mHTTP = rb_define_module_under(rb_define_module("Net"), "HTTP");
+  VALUE cParser = rb_define_class_under(mHTTP, "Parser", rb_cObject);
+  VALUE cRequestParser = rb_define_class_under(mHTTP, "RequestParser", cParser);
+  VALUE cResponseParser = rb_define_class_under(mHTTP, "ResponseParser", cParser);
+  
+  eParserError = rb_define_class_under(mHTTP, "ParseError", rb_eIOError);
+  sCall = rb_intern("call");
+  
+  // String constants
+  DEF_CONST(sPathInfo, "PATH_INFO");
+  DEF_CONST(sQueryString, "QUERY_STRING");
+  DEF_CONST(sURL, "REQUEST_URI");
+  DEF_CONST(sFragment, "FRAGMENT");
+  
+  rb_define_alloc_func(cParser, Parser_alloc);
+  rb_define_method(cParser, "on_message_complete=", Parser_set_on_message_complete, 1);
+  rb_define_method(cParser, "on_headers_complete=", Parser_set_on_headers_complete, 1);
+  rb_define_method(cParser, "on_body=", Parser_set_on_body, 1);
+
+  rb_define_method(cRequestParser, "<<", Parser_parse_requests, 1);
+  rb_define_method(cResponseParser, "<<", Parser_parse_responses, 1);
+}

data/lib/net/http/parser.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/../../ruby_http_parser"

data/ruby_http_parser.gemspec

@@ -0,0 +1,13 @@
+Gem::Specification.new do |s|
+  s.name = "ruby_http_parser"
+  s.version = "0.0.1"
+  s.summary = "Ruby bindings to http://github.com/ry/http-parser"
+  
+  s.author = "Marc-Andre Cournoyer"
+  s.email = "macournoyer@gmail.com"
+  s.files = Dir["**/*"]
+  s.homepage = "http://github.com/macournoyer/ruby_http_parser"
+  
+  s.require_paths = ["lib"]
+  s.extensions    = ["ext/ruby_http_parser/extconf.rb"]
+end

data/spec/request_parser_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe Net::HTTP::RequestParser do
+  before do
+    @parser = Net::HTTP::RequestParser.new
+  end
+  
+  it "should parse GET" do
+    env = nil
+    body = ""
+    
+    @parser.on_headers_complete = proc { |e| env = e }
+    @parser.on_body = proc { |chunk| body << chunk }
+    
+    @parser << "GET /test?ok=1 HTTP/1.1\r\n" +
+               "User-Agent: curl/7.18.0\r\n" +
+               "Host: 0.0.0.0:5000\r\n" +
+               "Accept: */*\r\n" +
+               "Content-Length: 5\r\n" +
+               "\r\n" +
+               "World"
+    
+    env["PATH_INFO"].should == "/test"
+    env["HTTP_HOST"].should == "0.0.0.0:5000"
+    body.should == "World"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require "rubygems"
+require "spec"
+require File.dirname(__FILE__) + "/../lib/net/http/parser"

data/tmp/universal-darwin10.0/ruby_http_parser/1.8.7/Makefile

@@ -0,0 +1,157 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = /Users/ma/projects/ruby_http_parser/ext/ruby_http_parser
+topdir = /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/universal-darwin10.0
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+exec_prefix = $(prefix)
+prefix = $(DESTDIR)/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr
+sharedstatedir = $(prefix)/com
+mandir = $(DESTDIR)/usr/share/man
+psdir = $(docdir)
+oldincludedir = $(DESTDIR)/usr/include
+localedir = $(datarootdir)/locale
+bindir = $(exec_prefix)/bin
+libexecdir = $(exec_prefix)/libexec
+sitedir = $(DESTDIR)/Library/Ruby/Site
+htmldir = $(docdir)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+includedir = $(prefix)/include
+infodir = $(DESTDIR)/usr/share/info
+vendorlibdir = $(vendordir)/$(ruby_version)
+sysconfdir = $(prefix)/etc
+libdir = $(exec_prefix)/lib
+sbindir = $(exec_prefix)/sbin
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+docdir = $(datarootdir)/doc/$(PACKAGE)
+dvidir = $(docdir)
+vendordir = $(libdir)/ruby/vendor_ruby
+datarootdir = $(prefix)/share
+pdfdir = $(docdir)
+archdir = $(rubylibdir)/$(arch)
+sitearchdir = $(sitelibdir)/$(sitearch)
+datadir = $(datarootdir)
+localstatedir = $(prefix)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+
+CC = gcc
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)
+
+RUBY_EXTCONF_H = 
+CFLAGS   =  -fno-common -arch i386 -arch x86_64 -g -Os -pipe -fno-common -DENABLE_DTRACE  -fno-common  -pipe -fno-common $(cflags) -I/Users/ma/projects/ruby_http_parser/ext/http-parser  
+INCFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =   -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE $(DEFS) $(cppflags)
+CXXFLAGS = $(CFLAGS) 
+ldflags  = -L. -arch i386 -arch x86_64 
+dldflags = 
+archflag = 
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = cc -arch i386 -arch x86_64 -pipe -bundle -undefined dynamic_lookup
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby
+arch = universal-darwin10.0
+sitearch = universal-darwin10.0
+ruby_version = 1.8
+ruby = /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl  
+SRCS = ruby_http_parser.c
+OBJS = ruby_http_parser.o
+TARGET = ruby_http_parser
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).bundle $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS)
+	@-$(RM) $@
+	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h