mongrel 1.0.5 → 1.1

data/CHANGELOG

@@ -1,6 +1,5 @@
-v1.0.5. Fix security flaw of DirHandler reported on mailing list.
 
-v1.0.4. Backport fixes for versioning inconsistency, mongrel_rails bug, and DirHandler bug.
+v1.1. Pure Ruby URIClassifier. More modular architecture. JRuby support. Move C URIClassifier into mongrel_experimental project.
 
 v1.0.3. Fix user-switching bug; make people upgrade to the latest from the RC.
 

data/LICENSE

@@ -1,6 +1,6 @@
 Mongrel Web Server (Mongrel) is copyrighted free software by Zed A. Shaw
-<zedshaw at zedshaw dot com> You can redistribute it and/or modify it under
-either the terms of the GPL or the conditions below:
+<zedshaw at zedshaw dot com> and contributors. You can redistribute it 
+and/or modify it under either the terms of the GPL2 or the conditions below:
 
 1. You may make and give away verbatim copies of the source form of the
    software without restriction, provided that you duplicate all of the

data/Manifest

@@ -22,33 +22,33 @@ ext/http11/http11_parser.h
 ext/http11/http11_parser.java.rl
 ext/http11/http11_parser.rl
 ext/http11/http11_parser_common.rl
-ext/http11/MANIFEST
-ext/http11/tst.h
-ext/http11/tst_cleanup.c
-ext/http11/tst_delete.c
-ext/http11/tst_grow_node_free_list.c
-ext/http11/tst_init.c
-ext/http11/tst_insert.c
-ext/http11/tst_search.c
+ext/http11_java/Http11Service.java
+ext/http11_java/org/jruby/mongrel/Http11.java
+ext/http11_java/org/jruby/mongrel/Http11Parser.java
 lib/mongrel/camping.rb
 lib/mongrel/cgi.rb
 lib/mongrel/command.rb
 lib/mongrel/configurator.rb
+lib/mongrel/const.rb
 lib/mongrel/debug.rb
+lib/mongrel/gems.rb
 lib/mongrel/handlers.rb
+lib/mongrel/header_out.rb
+lib/mongrel/http_request.rb
+lib/mongrel/http_response.rb
 lib/mongrel/init.rb
 lib/mongrel/mime_types.yml
 lib/mongrel/rails.rb
 lib/mongrel/stats.rb
 lib/mongrel/tcphack.rb
+lib/mongrel/uri_classifier.rb
 lib/mongrel.rb
-lib/mutex_fix.rb
 LICENSE
 Manifest
 mongrel-public_cert.pem
+mongrel.gemspec
 README
 setup.rb
-test/jruby_socket.rb
 test/mime.yaml
 test/mongrel.conf
 test/test_cgi_wrapper.rb
@@ -65,4 +65,5 @@ test/test_stats.rb
 test/test_uriclassifier.rb
 test/test_ws.rb
 test/testhelp.rb
+TODO
 tools/trickletest.rb

data/README

@@ -1,60 +1,53 @@
 = Mongrel:  Simple Fast Mostly Ruby Web Server
 
-Mongrel is a small library that provides a very fast HTTP 1.1 server for Ruby
-web applications.  It is not particular to any framework, and is intended to
-be just enough to get a web application running behind a more complete and robust
-web server.
+Mongrel is a small library that provides a very fast HTTP 1.1 server for Ruby web applications.  It is not particular to any framework, and is intended to be just enough to get a web application running behind a more complete and robust web server.
 
-What makes Mongrel so fast is the careful use of a C extension to provide fast
-HTTP 1.1 protocol parsing and fast URI lookup.  This combination makes the server
-scream without too many portability issues.
+What makes Mongrel so fast is the careful use of an Ragel extension to provide fast, accurate HTTP 1.1 protocol parsing. This makes the server scream without too many portability issues.
 
-You can view http://mongrel.rubyforge.org for more information.
+See http://mongrel.rubyforge.org for more information.
+
+== License
+
+Mongrel is copyright 2007 Zed A. Shaw and contributors. It is licensed under the Ruby license and the GPL2. See the include LICENSE file for details.
 
 == Quick Start
 
-After you've installed (either with gem install mongrel or via source) you should
-have the mongrel_rails command available in your PATH.  Then you just do the following:
+The easiest way to get started with Mongrel is to install it via RubyGems and then run a Ruby on Rails application. You can do this easily:
 
- > cd myrailsapp
- > mongrel_rails start
+ $ gem install mongrel
 
-This will start it in the foreground so you can play with it.  It runs your application
-in production mode.  To get help do:
+Now you should have the mongrel_rails command available in your PATH, so just do the following:
 
- > mongrel_rails start -h 
+ $ cd myrailsapp
+ $ mongrel_rails start
 
-Finally, you can then start in background mode (probably won't work in win32):
+This will start it in the foreground so you can play with it.  It runs your application in production mode.  To get help do:
 
- > mongrel_rails start -d
+ $ mongrel_rails start -h 
 
-And you can stop it whenever you like with:
+Finally, you can then start in background mode:
 
- > mongrel_rails stop
+ $ mongrel_rails start -d
+
+And you can stop it whenever you like with:
 
-All of which should be done from your application's directory.  It writes the
-PID of the process you ran into log/mongrel.pid.
+ $ mongrel_rails stop
 
-There are also many more new options for configuring the rails runner including
-changing to a different directory, adding more MIME types, and setting processor
-threads and timeouts.
+All of which should be done from your application's directory.  It writes the PID of the process you ran into log/mongrel.pid.
 
+There are also many more new options for configuring the rails runner including changing to a different directory, adding more MIME types, and setting processor threads and timeouts.
 
 == Install
 
-It doesn't explicitly require Camping, but if you want to run the examples/camping/
-examples then you'll need to install Camping 1.2 at least (and redcloth I think).  
-These are all available from RubyGems.
+It doesn't explicitly require Camping, but if you want to run the examples/camping/ examples then you'll need to install Camping 1.2 at least (and redcloth I think). These are all available from RubyGems.
 
-The library consists of a C extension so you'll need a C compiler or at least a friend
-who can build it for you.
+The library consists of a C extension so you'll need a C compiler or at least a friend who can build it for you.
 
 Finally, the source includes a setup.rb for those who hate RubyGems.
 
 == Usage
 
-The examples/simpletest.rb file has the following code as the simplest
-example:
+The examples/simpletest.rb file has the following code as the simplest example:
 
  require 'mongrel'
 
@@ -72,15 +65,10 @@ example:
  h.register("/files", Mongrel::DirHandler.new("."))
  h.run.join
 
-If you run this and access port 3000 with a browser it will say
-"hello!".  If you access it with any url other than "/test" it will
-give a simple 404.  Check out the Mongrel::Error404Handler for a 
-basic way to give a more complex 404 message.
+If you run this and access port 3000 with a browser it will say "hello!".  If you access it with any url other than "/test" it will give a simple 404.  Check out the Mongrel::Error404Handler for a basic way to give a more complex 404 message.
 
-This also shows the DirHandler with directory listings.  This is still
-rough but it should work for basic hosting.  *File extension to mime
-type mapping is missing though.*
+This also shows the DirHandler with directory listings.  This is still rough but it should work for basic hosting.  *File extension to mime type mapping is missing though.*
 
 == Contact
 
-E-mail zedshaw at zedshaw.com and I'll help.  Comments about the API are welcome.
+E-mail the Mongrel list at http://rubyforge.org/mailman/listinfo/mongrel-users and someone will help you. Comments about the API are welcome.

data/TODO

@@ -0,0 +1,5 @@
+
+v1.2. Rewrite and merge mongrel cluster and mongrel_rails into something small and maintainable. Remove gem_plugin entirely.
+
+v1.1.1. See if Java is setting the server version string in the request properly.
+

data/bin/mongrel_rails

@@ -124,7 +124,7 @@ module Mongrel
       end
 
       config.run
-      config.log "Mongrel available at #{@address}:#{@port}"
+      config.log "Mongrel #{Mongrel::Const::MONGREL_VERSION} available at #{@address}:#{@port}"
 
       if config.defaults[:daemon]
         config.write_pid_file

data/ext/http11/http11.c

@@ -8,11 +8,9 @@
 #include <string.h>
 #include "http11_parser.h"
 #include <ctype.h>
-#include "tst.h"
 
 static VALUE mMongrel;
 static VALUE cHttpParser;
-static VALUE cURIClassifier;
 static VALUE eHttpParserError;
 
 #define id_handler_map rb_intern("@handler_map")
@@ -363,191 +361,6 @@ VALUE HttpParser_nread(VALUE self)
   return INT2FIX(http->nread);
 }
 
-
-void URIClassifier_free(void *data) 
-{
-  TRACE();
-
-  if(data) {
-    tst_cleanup((struct tst *)data);
-  }
-}
-
-
-
-VALUE URIClassifier_alloc(VALUE klass)
-{
-  VALUE obj;
-  struct tst *tst = tst_init(TRIE_INCREASE);
-  TRACE();
-  assert(tst && "failed to initialize trie structure");
-
-  obj = Data_Wrap_Struct(klass, NULL, URIClassifier_free, tst);
-
-  return obj;
-}
-
-/**
- * call-seq:
- *    URIClassifier.new -> URIClassifier
- *
- * Initializes a new URIClassifier object that you can use to associate URI sequences
- * with objects.  You can actually use it with any string sequence and any objects,
- * but it's mostly used with URIs.
- *
- * It uses TST from http://www.octavian.org/cs/software.html to build an ternary search
- * trie to hold all of the URIs.  It uses this to do an initial search for the a URI
- * prefix, and then to break the URI into SCRIPT_NAME and PATH_INFO portions.  It actually
- * will do two searches most of the time in order to find the right handler for the
- * registered prefix portion.
- *
- */
-VALUE URIClassifier_init(VALUE self)
-{
-  VALUE hash;
-
-  /* we create an internal hash to protect stuff from the GC */
-  hash = rb_hash_new();
-  rb_ivar_set(self, id_handler_map, hash);
-
-  return self;
-}
-
-
-/**
- * call-seq:
- *    uc.register("/someuri", SampleHandler.new) -> nil
- *
- * Registers the SampleHandler (one for all requests) with the "/someuri".
- * When URIClassifier::resolve is called with "/someuri" it'll return
- * SampleHandler immediately.  When called with "/someuri/iwant" it'll also
- * return SomeHandler immediatly, with no additional searches, but it will
- * return path info with "/iwant".
- *
- * You actually can reuse this class to register nearly anything and 
- * quickly resolve it.  This could be used for caching, fast mapping, etc.
- * The downside is it uses much more memory than a Hash, but it can be
- * a lot faster.  It's main advantage is that it works on prefixes, which
- * is damn hard to get right with a Hash.
- */
-VALUE URIClassifier_register(VALUE self, VALUE uri, VALUE handler)
-{
-  int rc = 0;
-  void *ptr = NULL;
-  struct tst *tst = NULL;
-  DATA_GET(self, struct tst, tst);
-
-  rc = tst_insert((unsigned char *)StringValueCStr(uri), (void *)handler , tst, 0, &ptr);
-
-  if(rc == TST_DUPLICATE_KEY) {
-    rb_raise(rb_eStandardError, "Handler already registered with that name");
-  } else if(rc == TST_ERROR) {
-    rb_raise(rb_eStandardError, "Memory error registering handler");
-  } else if(rc == TST_NULL_KEY) {
-    rb_raise(rb_eStandardError, "URI was empty");
-  }
-
-  rb_hash_aset(rb_ivar_get(self, id_handler_map), uri, handler);
-
-  return Qnil;
-}
-
-
-/**
- * call-seq:
- *    uc.unregister("/someuri")
- *
- * Yep, just removes this uri and it's handler from the trie.
- */
-VALUE URIClassifier_unregister(VALUE self, VALUE uri)
-{
-  void *handler = NULL;
-  struct tst *tst = NULL;
-  DATA_GET(self, struct tst, tst);
-
-  handler = tst_delete((unsigned char *)StringValueCStr(uri), tst);
-
-  if(handler) {
-    rb_hash_delete(rb_ivar_get(self, id_handler_map), uri);
-
-    return (VALUE)handler;
-  } else {
-    return Qnil;
-  }
-}
-
-
-/**
- * call-seq:
- *    uc.resolve("/someuri") -> "/someuri", "", handler
- *    uc.resolve("/someuri/pathinfo") -> "/someuri", "/pathinfo", handler
- *    uc.resolve("/notfound/orhere") -> nil, nil, nil
- *    uc.resolve("/") -> "/", "/", handler  # if uc.register("/", handler)
- *    uc.resolve("/path/from/root") -> "/", "/path/from/root", handler  # if uc.register("/", handler) 
- * 
- * Attempts to resolve either the whole URI or at the longest prefix, returning
- * the prefix (as script_info), path (as path_info), and registered handler
- * (usually an HttpHandler).  If it doesn't find a handler registered at the longest
- * match then it returns nil,nil,nil.
- *
- * Because the resolver uses a trie you are able to register a handler at *any* character
- * in the URI and it will be handled as long as it's the longest prefix.  So, if you 
- * registered handler #1 at "/something/lik", and #2 at "/something/like/that", then a
- * a search for "/something/like" would give you #1.  A search for "/something/like/that/too"
- * would give you #2.
- * 
- * This is very powerful since it means you can also attach handlers to parts of the ; 
- * (semi-colon) separated path params, any part of the path, use off chars, anything really.
- * It also means that it's very efficient to do this only taking as long as the URI has
- * characters.
- *
- * A slight modification to the CGI 1.2 standard is given for handlers registered to "/".
- * CGI expects all CGI scripts to be at some script path, so it doesn't really say anything
- * about a script that handles the root.  To make this work, the resolver will detect that
- * the requested handler is at "/", and return that for script_name, and then simply return
- * the full URI back as path_info.
- *
- * It expects strings with no embedded '\0' characters.  Don't try other string-like stuff yet.
- */
-VALUE URIClassifier_resolve(VALUE self, VALUE uri)
-{
-  void *handler = NULL;
-  int pref_len = 0;
-  struct tst *tst = NULL;
-  VALUE result;
-  unsigned char *uri_str = NULL;
-
-  DATA_GET(self, struct tst, tst);
-  uri_str = (unsigned char *)StringValueCStr(uri);
-
-  handler = tst_search(uri_str, tst, TST_LONGEST_MATCH, &pref_len);
-
-  /* setup for multiple return values */
-  result = rb_ary_new();
-
-  if(handler) {
-    rb_ary_push(result, rb_str_substr (uri, 0, pref_len));
-    /* compensate for a script_name="/" where we need to add the "/" to path_info to keep it consistent */
-    if(pref_len == 1 && uri_str[0] == '/') {
-      /* matches the root URI so we have to use the whole URI as the path_info */
-      rb_ary_push(result, uri);
-    } else {
-      /* matches a script so process like normal */
-      rb_ary_push(result, rb_str_substr(uri, pref_len, RSTRING(uri)->len));
-    }
-
-    rb_ary_push(result, (VALUE)handler);
-  } else {
-    /* not found so push back nothing */
-    rb_ary_push(result, Qnil);
-    rb_ary_push(result, Qnil);
-    rb_ary_push(result, Qnil);
-  }
-
-  return result;
-}
-
-
 void Init_http11()
 {
 
@@ -571,7 +384,7 @@ void Init_http11()
   DEF_GLOBAL(server_protocol, "SERVER_PROTOCOL");
   DEF_GLOBAL(server_protocol_value, "HTTP/1.1");
   DEF_GLOBAL(http_host, "HTTP_HOST");
-  DEF_GLOBAL(mongrel_version, "Mongrel 1.0.5");
+  DEF_GLOBAL(mongrel_version, "Mongrel 1.1");
   DEF_GLOBAL(server_software, "SERVER_SOFTWARE");
   DEF_GLOBAL(port_80, "80");
 
@@ -586,11 +399,4 @@ void Init_http11()
   rb_define_method(cHttpParser, "error?", HttpParser_has_error,0);
   rb_define_method(cHttpParser, "finished?", HttpParser_is_finished,0);
   rb_define_method(cHttpParser, "nread", HttpParser_nread,0);
-
-  cURIClassifier = rb_define_class_under(mMongrel, "URIClassifier", rb_cObject);
-  rb_define_alloc_func(cURIClassifier, URIClassifier_alloc);
-  rb_define_method(cURIClassifier, "initialize", URIClassifier_init, 0);
-  rb_define_method(cURIClassifier, "register", URIClassifier_register, 2);
-  rb_define_method(cURIClassifier, "unregister", URIClassifier_unregister, 1);
-  rb_define_method(cURIClassifier, "resolve", URIClassifier_resolve, 1);
 }

data/ext/http11_java/Http11Service.java

@@ -0,0 +1,13 @@
+import java.io.IOException;
+        
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+import org.jruby.mongrel.Http11;
+
+public class Http11Service implements BasicLibraryService { 
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        Http11.createHttp11(runtime);
+        return true;
+    }
+}

data/ext/http11_java/org/jruby/mongrel/Http11.java

@@ -0,0 +1,266 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: CPL 1.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Common Public
+ * License Version 1.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Copyright (C) 2007 Ola Bini <ola@ologix.com>
+ * 
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the CPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+package org.jruby.mongrel;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+
+import org.jruby.runtime.CallbackFactory;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+
+import org.jruby.exceptions.RaiseException;
+
+import org.jruby.util.ByteList;
+
+/**
+ * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a>
+ */
+public class Http11 extends RubyObject {
+    public final static int MAX_FIELD_NAME_LENGTH = 256;
+    public final static String MAX_FIELD_NAME_LENGTH_ERR = "HTTP element FIELD_NAME is longer than the 256 allowed length.";
+    public final static int MAX_FIELD_VALUE_LENGTH = 80 * 1024;
+    public final static String MAX_FIELD_VALUE_LENGTH_ERR = "HTTP element FIELD_VALUE is longer than the 81920 allowed length.";
+    public final static int MAX_REQUEST_URI_LENGTH = 1024 * 12;
+    public final static String MAX_REQUEST_URI_LENGTH_ERR = "HTTP element REQUEST_URI is longer than the 12288 allowed length.";
+    public final static int MAX_FRAGMENT_LENGTH = 1024;
+    public final static String MAX_FRAGMENT_LENGTH_ERR = "HTTP element REQUEST_PATH is longer than the 1024 allowed length.";
+    public final static int MAX_REQUEST_PATH_LENGTH = 1024;
+    public final static String MAX_REQUEST_PATH_LENGTH_ERR = "HTTP element REQUEST_PATH is longer than the 1024 allowed length.";
+    public final static int MAX_QUERY_STRING_LENGTH = 1024 * 10;
+    public final static String MAX_QUERY_STRING_LENGTH_ERR = "HTTP element QUERY_STRING is longer than the 10240 allowed length.";
+    public final static int MAX_HEADER_LENGTH = 1024 * (80 + 32);
+    public final static String MAX_HEADER_LENGTH_ERR = "HTTP element HEADER is longer than the 114688 allowed length.";
+
+
+    private static ObjectAllocator ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+            return new Http11(runtime, klass);
+        }
+    };
+
+    public static void createHttp11(Ruby runtime) {
+        RubyModule mMongrel = runtime.defineModule("Mongrel");
+        mMongrel.defineClassUnder("HttpParserError",runtime.getClass("IOError"),runtime.getClass("IOError").getAllocator());
+
+        CallbackFactory cf = runtime.callbackFactory(Http11.class);
+
+        RubyClass cHttpParser = mMongrel.defineClassUnder("HttpParser",runtime.getObject(),ALLOCATOR);
+        cHttpParser.defineFastMethod("initialize",cf.getFastMethod("initialize"));
+        cHttpParser.defineFastMethod("reset",cf.getFastMethod("reset"));
+        cHttpParser.defineFastMethod("finish",cf.getFastMethod("finish"));
+        cHttpParser.defineFastMethod("execute",cf.getFastMethod("execute", IRubyObject.class, IRubyObject.class, IRubyObject.class));
+        cHttpParser.defineFastMethod("error?",cf.getFastMethod("has_error"));
+        cHttpParser.defineFastMethod("finished?",cf.getFastMethod("is_finished"));
+        cHttpParser.defineFastMethod("nread",cf.getFastMethod("nread"));
+    }
+
+    private Ruby runtime;
+    private RubyClass eHttpParserError;
+    private Http11Parser hp;
+
+    public Http11(Ruby runtime, RubyClass clazz) {
+        super(runtime,clazz);
+        this.runtime = runtime;
+        this.eHttpParserError = (RubyClass)runtime.getModule("Mongrel").getConstant("HttpParserError");
+        this.hp = new Http11Parser();
+        this.hp.parser.http_field = http_field;
+        this.hp.parser.request_method = request_method;
+        this.hp.parser.request_uri = request_uri;
+        this.hp.parser.fragment = fragment;
+        this.hp.parser.request_path = request_path;
+        this.hp.parser.query_string = query_string;
+        this.hp.parser.http_version = http_version;
+        this.hp.parser.header_done = header_done;
+        this.hp.parser.init();
+    }
+
+    public void validateMaxLength(int len, int max, String msg) {
+        if(len>max) {
+            throw new RaiseException(runtime, eHttpParserError, msg, true);
+        }
+    }
+
+    private Http11Parser.FieldCB http_field = new Http11Parser.FieldCB() {
+            public void call(Object data, int field, int flen, int value, int vlen) {
+                RubyHash req = (RubyHash)data;
+                RubyString v,f;
+                validateMaxLength(flen, MAX_FIELD_NAME_LENGTH, MAX_FIELD_NAME_LENGTH_ERR);
+                validateMaxLength(vlen, MAX_FIELD_VALUE_LENGTH, MAX_FIELD_VALUE_LENGTH_ERR);
+
+                v = RubyString.newString(runtime, new ByteList(Http11.this.hp.parser.buffer,value,vlen));
+                f = RubyString.newString(runtime, "HTTP_");
+                ByteList b = new ByteList(Http11.this.hp.parser.buffer,field,flen);
+                for(int i=0,j=b.realSize;i<j;i++) {
+                    if((b.bytes[i]&0xFF) == '-') {
+                        b.bytes[i] = (byte)'_';
+                    } else {
+                        b.bytes[i] = (byte)Character.toUpperCase((char)b.bytes[i]);
+                    }
+                }
+                f.cat(b);
+                req.aset(f,v);
+            }
+        };
+
+    private Http11Parser.ElementCB request_method = new Http11Parser.ElementCB() {
+            public void call(Object data, int at, int length) {
+                RubyHash req = (RubyHash)data;
+                RubyString val = RubyString.newString(runtime,new ByteList(hp.parser.buffer,at,length));
+                req.aset(runtime.newString("REQUEST_METHOD"),val);
+            }
+        };
+
+    private Http11Parser.ElementCB request_uri = new Http11Parser.ElementCB() {
+            public void call(Object data, int at, int length) {
+                RubyHash req = (RubyHash)data;
+                validateMaxLength(length, MAX_REQUEST_URI_LENGTH, MAX_REQUEST_URI_LENGTH_ERR);
+                RubyString val = RubyString.newString(runtime,new ByteList(hp.parser.buffer,at,length));
+                req.aset(runtime.newString("REQUEST_URI"),val);
+            }
+        };
+
+    private Http11Parser.ElementCB fragment = new Http11Parser.ElementCB() {
+            public void call(Object data, int at, int length) {
+                RubyHash req = (RubyHash)data;
+                validateMaxLength(length, MAX_FRAGMENT_LENGTH, MAX_FRAGMENT_LENGTH_ERR);
+                RubyString val = RubyString.newString(runtime,new ByteList(hp.parser.buffer,at,length));
+                req.aset(runtime.newString("FRAGMENT"),val);
+            }
+        };
+
+    private Http11Parser.ElementCB request_path = new Http11Parser.ElementCB() {
+            public void call(Object data, int at, int length) {
+                RubyHash req = (RubyHash)data;
+                validateMaxLength(length, MAX_REQUEST_PATH_LENGTH, MAX_REQUEST_PATH_LENGTH_ERR);
+                RubyString val = RubyString.newString(runtime,new ByteList(hp.parser.buffer,at,length));
+                req.aset(runtime.newString("REQUEST_PATH"),val);
+            }
+        };
+
+    private Http11Parser.ElementCB query_string = new Http11Parser.ElementCB() {
+            public void call(Object data, int at, int length) {
+                RubyHash req = (RubyHash)data;
+                validateMaxLength(length, MAX_QUERY_STRING_LENGTH, MAX_QUERY_STRING_LENGTH_ERR);
+                RubyString val = RubyString.newString(runtime,new ByteList(hp.parser.buffer,at,length));
+                req.aset(runtime.newString("QUERY_STRING"),val);
+            }
+        };
+
+    private Http11Parser.ElementCB http_version = new Http11Parser.ElementCB() {
+            public void call(Object data, int at, int length) {
+                RubyHash req = (RubyHash)data;
+                RubyString val = RubyString.newString(runtime,new ByteList(hp.parser.buffer,at,length));
+                req.aset(runtime.newString("HTTP_VERSION"),val);
+            }
+        };
+
+    private Http11Parser.ElementCB header_done = new Http11Parser.ElementCB() {
+            public void call(Object data, int at, int length) {
+                RubyHash req = (RubyHash)data;
+                IRubyObject temp,ctype,clen;
+                
+                clen = req.aref(runtime.newString("HTTP_CONTENT_LENGTH"));
+                if(!clen.isNil()) {
+                    req.aset(runtime.newString("CONTENT_LENGTH"),clen);
+                }
+
+                ctype = req.aref(runtime.newString("HTTP_CONTENT_TYPE"));
+                if(!ctype.isNil()) {
+                    req.aset(runtime.newString("CONTENT_TYPE"),ctype);
+                }
+
+                req.aset(runtime.newString("GATEWAY_INTERFACE"),runtime.newString("CGI/1.2"));
+                if(!(temp = req.aref(runtime.newString("HTTP_HOST"))).isNil()) {
+                    String s = temp.toString();
+                    int colon = s.indexOf(':');
+                    if(colon != -1) {
+                        req.aset(runtime.newString("SERVER_NAME"),runtime.newString(s.substring(0,colon)));
+                        req.aset(runtime.newString("SERVER_PORT"),runtime.newString(s.substring(colon+1)));
+                    } else {
+                        req.aset(runtime.newString("SERVER_NAME"),temp);
+                        req.aset(runtime.newString("SERVER_PORT"),runtime.newString("80"));
+                    }
+                }
+
+                req.setInstanceVariable("@http_body", RubyString.newString(runtime, new ByteList(hp.parser.buffer, at, length)));
+                req.aset(runtime.newString("SERVER_PROTOCOL"),runtime.newString("HTTP/1.1"));
+                req.aset(runtime.newString("SERVER_SOFTWARE"),runtime.newString("Mongrel 1.0.1"));
+            }
+        };
+
+    public IRubyObject initialize() {
+        this.hp.parser.init();
+        return this;
+    }
+
+    public IRubyObject reset() {
+        this.hp.parser.init();
+        return runtime.getNil();
+    }
+
+    public IRubyObject finish() {
+        this.hp.finish();
+        return this.hp.is_finished() ? runtime.getTrue() : runtime.getFalse();
+    }
+
+    public IRubyObject execute(IRubyObject req_hash, IRubyObject data, IRubyObject start) {
+        int from = 0;
+        from = RubyNumeric.fix2int(start);
+        ByteList d = ((RubyString)data).getByteList();
+        if(from >= d.realSize) {
+            throw new RaiseException(runtime, eHttpParserError, "Requested start is after data buffer end.", true);
+        } else {
+            this.hp.parser.data = req_hash;
+            this.hp.execute(d,from);
+            validateMaxLength(this.hp.parser.nread,MAX_HEADER_LENGTH, MAX_HEADER_LENGTH_ERR);
+            if(this.hp.has_error()) {
+                throw new RaiseException(runtime, eHttpParserError, "Invalid HTTP format, parsing fails.", true);
+            } else {
+                return runtime.newFixnum(this.hp.parser.nread);
+            }
+        }
+    }
+
+    public IRubyObject has_error() {
+        return this.hp.has_error() ? runtime.getTrue() : runtime.getFalse();
+    }
+
+    public IRubyObject is_finished() {
+        return this.hp.is_finished() ? runtime.getTrue() : runtime.getFalse();
+    }
+
+    public IRubyObject nread() {
+        return runtime.newFixnum(this.hp.parser.nread);
+    }
+}// Http11