RubyGems - mongrel - Versions diffs - 1.2.0.pre2-x86-mswin32 - Mend

mongrel 1.2.0.pre2-x86-mswin32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (72) hide show

data/COPYING +55 -0
data/History.txt +68 -0
data/LICENSE +55 -0
data/Manifest.txt +69 -0
data/README.txt +80 -0
data/Rakefile +8 -0
data/TODO +5 -0
data/bin/mongrel_rails +284 -0
data/examples/builder.rb +29 -0
data/examples/camping/README +3 -0
data/examples/camping/blog.rb +294 -0
data/examples/camping/tepee.rb +149 -0
data/examples/httpd.conf +474 -0
data/examples/mime.yaml +3 -0
data/examples/mongrel.conf +9 -0
data/examples/monitrc +57 -0
data/examples/random_thrash.rb +19 -0
data/examples/simpletest.rb +52 -0
data/examples/webrick_compare.rb +20 -0
data/ext/http11/Http11Service.java +13 -0
data/ext/http11/ext_help.h +15 -0
data/ext/http11/extconf.rb +6 -0
data/ext/http11/http11.c +534 -0
data/ext/http11/http11_parser.c +1243 -0
data/ext/http11/http11_parser.h +49 -0
data/ext/http11/http11_parser.java.rl +159 -0
data/ext/http11/http11_parser.rl +153 -0
data/ext/http11/http11_parser_common.rl +54 -0
data/ext/http11/org/jruby/mongrel/Http11.java +241 -0
data/ext/http11/org/jruby/mongrel/Http11Parser.java +486 -0
data/lib/1.8/http11.so +0 -0
data/lib/1.9/http11.so +0 -0
data/lib/mongrel.rb +366 -0
data/lib/mongrel/camping.rb +107 -0
data/lib/mongrel/cgi.rb +181 -0
data/lib/mongrel/command.rb +220 -0
data/lib/mongrel/configurator.rb +388 -0
data/lib/mongrel/const.rb +110 -0
data/lib/mongrel/debug.rb +203 -0
data/lib/mongrel/gems.rb +22 -0
data/lib/mongrel/handlers.rb +468 -0
data/lib/mongrel/header_out.rb +28 -0
data/lib/mongrel/http_request.rb +155 -0
data/lib/mongrel/http_response.rb +166 -0
data/lib/mongrel/init.rb +10 -0
data/lib/mongrel/mime_types.yml +616 -0
data/lib/mongrel/rails.rb +185 -0
data/lib/mongrel/stats.rb +89 -0
data/lib/mongrel/tcphack.rb +18 -0
data/lib/mongrel/uri_classifier.rb +76 -0
data/setup.rb +1585 -0
data/tasks/gem.rake +28 -0
data/tasks/native.rake +24 -0
data/tasks/ragel.rake +20 -0
data/test/mime.yaml +3 -0
data/test/mongrel.conf +1 -0
data/test/test_cgi_wrapper.rb +26 -0
data/test/test_command.rb +86 -0
data/test/test_conditional.rb +107 -0
data/test/test_configurator.rb +87 -0
data/test/test_debug.rb +25 -0
data/test/test_handlers.rb +135 -0
data/test/test_http11.rb +156 -0
data/test/test_redirect_handler.rb +44 -0
data/test/test_request_progress.rb +99 -0
data/test/test_response.rb +127 -0
data/test/test_stats.rb +35 -0
data/test/test_uriclassifier.rb +261 -0
data/test/test_ws.rb +117 -0
data/test/testhelp.rb +71 -0
data/tools/trickletest.rb +45 -0
metadata +197 -0

data/examples/mime.yaml ADDED

@@ -0,0 +1,3 @@
+---
+.jpeg: image/jpeg
+.png: image/test

data/examples/mongrel.conf ADDED

@@ -0,0 +1,9 @@
+---
+:environment: production
+:daemon: "true"
+:host: 0.0.0.0
+:log_file: log/mongrel.log
+:docroot: public
+:debug: "false"
+:port: 3000
+:pid_file: log/mongrel.pid

data/examples/monitrc ADDED

@@ -0,0 +1,57 @@
+set daemon  60
+set logfile syslog facility log_daemon
+set mailserver localhost
+set mail-format { from: monit@localhost }
+set alert root@localhost
+check process sshd with pidfile /var/run/sshd.pid
+   start program  "/etc/init.d/ssh start"
+   stop program  "/etc/init.d/ssh stop"
+   if failed port 22 protocol ssh then restart
+   if 5 restarts within 5 cycles then timeout
+check process mysql with pidfile /var/run/mysqld/mysqld.pid
+   group database
+   start program = "/etc/init.d/mysql start"
+   stop program = "/etc/init.d/mysql stop"
+   if failed host 127.0.0.1 port 3306 then restart
+   if 5 restarts within 5 cycles then timeout
+check process httpd with pidfile /usr/local/apache2/logs/httpd.pid
+   group www-data
+   start program  "/usr/local/apache2/bin/apachectl start"
+   stop program  "/usr/local/apache2/bin/apachectl stop"
+   if failed host localhost port 80 protocol http
+      and request "/" then alert
+   if cpu is greater than 60% for 2 cycles then alert
+   if cpu > 80% for 5 cycles then restart
+   if children > 250 then restart
+   if loadavg(5min) greater than 10 for 8 cycles then alert
+   if 3 restarts within 5 cycles then timeout
+check process mongrel_8000 with pidfile /var/rails/MYAPP/log/mongrel.8000.pid
+   group root
+   if failed host 127.0.0.1 port 8000 protocol http
+      and request "/" then alert
+   if cpu is greater than 60% for 2 cycles then alert
+   if cpu > 80% for 5 cycles then restart
+   if loadavg(5min) greater than 10 for 8 cycles then restart
+   if 3 restarts within 5 cycles then timeout
+check process mongrel_8001 with pidfile /var/rails/MYAPP/log/mongrel.8001.pid
+   group root
+   if failed host 127.0.0.1 port 8001 protocol http
+      and request "/" then alert
+   if cpu is greater than 60% for 2 cycles then alert
+   if cpu > 80% for 5 cycles then alert
+   if loadavg(5min) greater than 10 for 8 cycles then alert
+   if 3 restarts within 5 cycles then timeout
+check process postfix with pidfile /var/spool/postfix/pid/master.pid
+   group mail
+   start program = "/etc/init.d/postfix start"
+   stop  program = "/etc/init.d/postfix stop"
+   if failed port 25 protocol smtp then restart
+   if 5 restarts within 5 cycles then timeout

data/examples/random_thrash.rb ADDED

@@ -0,0 +1,19 @@
+require 'socket'
+devrand = open("/dev/random","r")
+loop do
+  s = TCPSocket.new(ARGV[0],ARGV[1])
+  s.write("GET / HTTP/1.1\r\n")
+  total = 0
+  begin
+    loop do
+       r = devrand.read(10)
+       n = s.write(r)
+       total += n
+    end
+  rescue Object
+	STDERR.puts "#$!: #{total}"
+  end
+   s.close
+   sleep 1
+end

data/examples/simpletest.rb ADDED

@@ -0,0 +1,52 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), "..", "lib")
+require 'mongrel'
+require 'yaml'
+class SimpleHandler < Mongrel::HttpHandler
+  def process(request, response)
+    response.start do |head,out|
+      head["Content-Type"] = "text/html"
+      results = "<html><body>Your request:<br /><pre>#{request.params.to_yaml}</pre><a href=\"/files\">View the files.</a></body></html>"
+      out << results
+    end
+  end
+end
+class DumbHandler < Mongrel::HttpHandler
+  def process(request, response)
+    response.start do |head,out|
+      head["Content-Type"] = "text/html"
+      out.write("test")
+    end
+  end
+end
+if ARGV.length != 3
+  STDERR.puts "usage:  simpletest.rb <host> <port> <docroot>"
+  exit(1)
+end
+stats = Mongrel::StatisticsFilter.new(:sample_rate => 1)
+config = Mongrel::Configurator.new :host => ARGV[0], :port => ARGV[1] do
+  listener do
+    uri "/", :handler => SimpleHandler.new
+    uri "/", :handler => Mongrel::DeflateFilter.new
+    uri "/", :handler => stats
+    uri "/dumb", :handler => DumbHandler.new
+    uri "/dumb", :handler => Mongrel::DeflateFilter.new
+    uri "/dumb", :handler => stats
+    uri "/files", :handler => Mongrel::DirHandler.new(ARGV[2])
+    uri "/files", :handler => stats
+    uri "/status", :handler => Mongrel::StatusHandler.new(:stats_filter => stats)
+    redirect "/redir1", "/"
+    redirect "/to", /to/, 'w'
+  end
+  trap("INT") { stop }
+  run
+end
+puts "Mongrel running on #{ARGV[0]}:#{ARGV[1]} with docroot #{ARGV[2]}"
+config.join

data/examples/webrick_compare.rb ADDED

@@ -0,0 +1,20 @@
+#!/usr/local/bin/ruby
+require 'webrick'
+include WEBrick
+s = HTTPServer.new( :Port => 4000 )
+# HTTPServer#mount(path, servletclass)
+#   When a request referring "/hello" is received,
+#   the HTTPServer get an instance of servletclass
+#   and then call a method named do_"a HTTP method".
+class HelloServlet < HTTPServlet::AbstractServlet
+  def do_GET(req, res)
+    res.body = "hello!"
+    res['Content-Type'] = "text/html"
+  end
+end
+s.mount("/test", HelloServlet)
+s.start

data/ext/http11/Http11Service.java ADDED

@@ -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/ext_help.h ADDED

@@ -0,0 +1,15 @@
+#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);
+#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
+#ifdef DEBUG
+#define TRACE()  fprintf(stderr, "> %s:%d:%s\n", __FILE__, __LINE__, __FUNCTION__)
+#else
+#define TRACE()
+#endif
+#endif

data/ext/http11/extconf.rb ADDED

@@ -0,0 +1,6 @@
+require 'mkmf'
+dir_config("http11")
+have_library("c", "main")
+create_makefile("http11")

data/ext/http11/http11.c ADDED

@@ -0,0 +1,534 @@
+/**
+ * Copyright (c) 2005 Zed A. Shaw
+ * You can redistribute it and/or modify it under the same terms as Ruby.
+ */
+#include "ruby.h"
+#include "ext_help.h"
+#include <assert.h>
+#include <string.h>
+#include "http11_parser.h"
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+static VALUE mMongrel;
+static VALUE cHttpParser;
+static VALUE eHttpParserError;
+#define id_handler_map rb_intern("@handler_map")
+#define id_http_body rb_intern("@http_body")
+#define HTTP_PREFIX "HTTP_"
+#define HTTP_PREFIX_LEN (sizeof(HTTP_PREFIX) - 1)
+static VALUE global_request_method;
+static VALUE global_request_uri;
+static VALUE global_fragment;
+static VALUE global_query_string;
+static VALUE global_http_version;
+static VALUE global_content_length;
+static VALUE global_http_content_length;
+static VALUE global_request_path;
+static VALUE global_content_type;
+static VALUE global_http_content_type;
+static VALUE global_gateway_interface;
+static VALUE global_gateway_interface_value;
+static VALUE global_server_name;
+static VALUE global_server_port;
+static VALUE global_server_protocol;
+static VALUE global_server_protocol_value;
+static VALUE global_http_host;
+static VALUE global_mongrel_version;
+static VALUE global_server_software;
+static VALUE global_port_80;
+#define TRIE_INCREASE 30
+/** Defines common length and error messages for input length validation. */
+#define DEF_MAX_LENGTH(N,length) const size_t MAX_##N##_LENGTH = length; const char *MAX_##N##_LENGTH_ERR = "HTTP element " # N  " is longer than the " # length " allowed length."
+/** Validates the max length of given input and throws an HttpParserError exception if over. */
+#define VALIDATE_MAX_LENGTH(len, N) if(len > MAX_##N##_LENGTH) { rb_raise(eHttpParserError, MAX_##N##_LENGTH_ERR); }
+/** Defines global strings in the init method. */
+#define DEF_GLOBAL(N, val)   global_##N = rb_obj_freeze(rb_str_new2(val)); rb_global_variable(&global_##N)
+/* Defines the maximum allowed lengths for various input elements.*/
+DEF_MAX_LENGTH(FIELD_NAME, 256);
+DEF_MAX_LENGTH(FIELD_VALUE, 80 * 1024);
+DEF_MAX_LENGTH(REQUEST_URI, 1024 * 12);
+DEF_MAX_LENGTH(FRAGMENT, 1024); /* Don't know if this length is specified somewhere or not */
+DEF_MAX_LENGTH(REQUEST_PATH, 1024);
+DEF_MAX_LENGTH(QUERY_STRING, (1024 * 10));
+DEF_MAX_LENGTH(HEADER, (1024 * (80 + 32)));
+struct common_field {
+	const signed long len;
+	const char *name;
+	VALUE value;
+};
+/*
+ * A list of common HTTP headers we expect to receive.
+ * This allows us to avoid repeatedly creating identical string
+ * objects to be used with rb_hash_aset().
+ */
+static struct common_field common_http_fields[] = {
+# define f(N) { (sizeof(N) - 1), N, Qnil }
+	f("ACCEPT"),
+	f("ACCEPT_CHARSET"),
+	f("ACCEPT_ENCODING"),
+	f("ACCEPT_LANGUAGE"),
+	f("ALLOW"),
+	f("AUTHORIZATION"),
+	f("CACHE_CONTROL"),
+	f("CONNECTION"),
+	f("CONTENT_ENCODING"),
+	f("CONTENT_LENGTH"),
+	f("CONTENT_TYPE"),
+	f("COOKIE"),
+	f("DATE"),
+	f("EXPECT"),
+	f("FROM"),
+	f("HOST"),
+	f("IF_MATCH"),
+	f("IF_MODIFIED_SINCE"),
+	f("IF_NONE_MATCH"),
+	f("IF_RANGE"),
+	f("IF_UNMODIFIED_SINCE"),
+	f("KEEP_ALIVE"), /* Firefox sends this */
+	f("MAX_FORWARDS"),
+	f("PRAGMA"),
+	f("PROXY_AUTHORIZATION"),
+	f("RANGE"),
+	f("REFERER"),
+	f("TE"),
+	f("TRAILER"),
+	f("TRANSFER_ENCODING"),
+	f("UPGRADE"),
+	f("USER_AGENT"),
+	f("VIA"),
+	f("X_FORWARDED_FOR"), /* common for proxies */
+	f("X_REAL_IP"), /* common for proxies */
+	f("WARNING")
+# undef f
+};
+/*
+ * qsort(3) and bsearch(3) improve average performance slightly, but may
+ * not be worth it for lack of portability to certain platforms...
+ */
+#if defined(HAVE_QSORT_BSEARCH)
+/* sort by length, then by name if there's a tie */
+static int common_field_cmp(const void *a, const void *b)
+{
+  struct common_field *cfa = (struct common_field *)a;
+  struct common_field *cfb = (struct common_field *)b;
+  signed long diff = cfa->len - cfb->len;
+  return diff ? diff : memcmp(cfa->name, cfb->name, cfa->len);
+}
+#endif /* HAVE_QSORT_BSEARCH */
+static void init_common_fields(void)
+{
+  int i;
+  struct common_field *cf = common_http_fields;
+  char tmp[256]; /* MAX_FIELD_NAME_LENGTH */
+  memcpy(tmp, HTTP_PREFIX, HTTP_PREFIX_LEN);
+  for(i = 0; i < ARRAY_SIZE(common_http_fields); cf++, i++) {
+    memcpy(tmp + HTTP_PREFIX_LEN, cf->name, cf->len + 1);
+    cf->value = rb_obj_freeze(rb_str_new(tmp, HTTP_PREFIX_LEN + cf->len));
+    rb_global_variable(&cf->value);
+  }
+#if defined(HAVE_QSORT_BSEARCH)
+  qsort(common_http_fields,
+        ARRAY_SIZE(common_http_fields),
+        sizeof(struct common_field),
+        common_field_cmp);
+#endif /* HAVE_QSORT_BSEARCH */
+}
+static VALUE find_common_field_value(const char *field, size_t flen)
+{
+#if defined(HAVE_QSORT_BSEARCH)
+  struct common_field key;
+  struct common_field *found;
+  key.name = field;
+  key.len = (signed long)flen;
+  found = (struct common_field *)bsearch(&key, common_http_fields,
+                                         ARRAY_SIZE(common_http_fields),
+                                         sizeof(struct common_field),
+                                         common_field_cmp);
+  return found ? found->value : Qnil;
+#else /* !HAVE_QSORT_BSEARCH */
+  int i;
+  struct common_field *cf = common_http_fields;
+  for(i = 0; i < ARRAY_SIZE(common_http_fields); i++, cf++) {
+    if (cf->len == flen && !memcmp(cf->name, field, flen))
+      return cf->value;
+  }
+  return Qnil;
+#endif /* !HAVE_QSORT_BSEARCH */
+}
+void http_field(void *data, const char *field, size_t flen, const char *value, size_t vlen)
+{
+  VALUE req = (VALUE)data;
+  VALUE v = Qnil;
+  VALUE f = Qnil;
+  VALIDATE_MAX_LENGTH(flen, FIELD_NAME);
+  VALIDATE_MAX_LENGTH(vlen, FIELD_VALUE);
+  v = rb_str_new(value, vlen);
+  f = find_common_field_value(field, flen);
+  if (f == Qnil) {
+    /*
+     * We got a strange header that we don't have a memoized value for.
+     * Fallback to creating a new string to use as a hash key.
+     *
+     * using rb_str_new(NULL, len) here is faster than rb_str_buf_new(len)
+     * in my testing, because: there's no minimum allocation length (and
+     * no check for it, either), RSTRING_LEN(f) does not need to be
+     * written twice, and and RSTRING_PTR(f) will already be
+     * null-terminated for us.
+     */
+    f = rb_str_new(NULL, HTTP_PREFIX_LEN + flen);
+    memcpy(RSTRING_PTR(f), HTTP_PREFIX, HTTP_PREFIX_LEN);
+    memcpy(RSTRING_PTR(f) + HTTP_PREFIX_LEN, field, flen);
+    assert(*(RSTRING_PTR(f) + RSTRING_LEN(f)) == '\0'); /* paranoia */
+    /* fprintf(stderr, "UNKNOWN HEADER <%s>\n", RSTRING_PTR(f)); */
+  }
+  rb_hash_aset(req, f, v);
+}
+void request_method(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE val = Qnil;
+  val = rb_str_new(at, length);
+  rb_hash_aset(req, global_request_method, val);
+}
+void request_uri(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE val = Qnil;
+  VALIDATE_MAX_LENGTH(length, REQUEST_URI);
+  val = rb_str_new(at, length);
+  rb_hash_aset(req, global_request_uri, val);
+}
+void fragment(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE val = Qnil;
+  VALIDATE_MAX_LENGTH(length, FRAGMENT);
+  val = rb_str_new(at, length);
+  rb_hash_aset(req, global_fragment, val);
+}
+void request_path(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE val = Qnil;
+  VALIDATE_MAX_LENGTH(length, REQUEST_PATH);
+  val = rb_str_new(at, length);
+  rb_hash_aset(req, global_request_path, val);
+}
+void query_string(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE val = Qnil;
+  VALIDATE_MAX_LENGTH(length, QUERY_STRING);
+  val = rb_str_new(at, length);
+  rb_hash_aset(req, global_query_string, val);
+}
+void http_version(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE val = rb_str_new(at, length);
+  rb_hash_aset(req, global_http_version, val);
+}
+/** Finalizes the request header to have a bunch of stuff that's
+  needed. */
+void header_done(void *data, const char *at, size_t length)
+{
+  VALUE req = (VALUE)data;
+  VALUE temp = Qnil;
+  VALUE ctype = Qnil;
+  VALUE clen = Qnil;
+  char *colon = NULL;
+  clen = rb_hash_aref(req, global_http_content_length);
+  if(clen != Qnil) {
+    rb_hash_aset(req, global_content_length, clen);
+  }
+  ctype = rb_hash_aref(req, global_http_content_type);
+  if(ctype != Qnil) {
+    rb_hash_aset(req, global_content_type, ctype);
+  }
+  rb_hash_aset(req, global_gateway_interface, global_gateway_interface_value);
+  if((temp = rb_hash_aref(req, global_http_host)) != Qnil) {
+    colon = memchr(RSTRING_PTR(temp), ':', RSTRING_LEN(temp));
+    if(colon != NULL) {
+      rb_hash_aset(req, global_server_name, rb_str_substr(temp, 0, colon - RSTRING_PTR(temp)));
+      rb_hash_aset(req, global_server_port,
+          rb_str_substr(temp, colon - RSTRING_PTR(temp)+1,
+            RSTRING_LEN(temp)));
+    } else {
+      rb_hash_aset(req, global_server_name, temp);
+      rb_hash_aset(req, global_server_port, global_port_80);
+    }
+  }
+  /* grab the initial body and stuff it into an ivar */
+  rb_ivar_set(req, id_http_body, rb_str_new(at, length));
+  rb_hash_aset(req, global_server_protocol, global_server_protocol_value);
+  rb_hash_aset(req, global_server_software, global_mongrel_version);
+}
+void HttpParser_free(void *data) {
+  TRACE();
+  if(data) {
+    free(data);
+  }
+}
+VALUE HttpParser_alloc(VALUE klass)
+{
+  VALUE obj;
+  http_parser *hp = ALLOC_N(http_parser, 1);
+  TRACE();
+  hp->http_field = http_field;
+  hp->request_method = request_method;
+  hp->request_uri = request_uri;
+  hp->fragment = fragment;
+  hp->request_path = request_path;
+  hp->query_string = query_string;
+  hp->http_version = http_version;
+  hp->header_done = header_done;
+  http_parser_init(hp);
+  obj = Data_Wrap_Struct(klass, NULL, HttpParser_free, hp);
+  return obj;
+}
+/**
+ * call-seq:
+ *    parser.new -> parser
+ *
+ * Creates a new parser.
+ */
+VALUE HttpParser_init(VALUE self)
+{
+  http_parser *http = NULL;
+  DATA_GET(self, http_parser, http);
+  http_parser_init(http);
+  return self;
+}
+/**
+ * call-seq:
+ *    parser.reset -> nil
+ *
+ * Resets the parser to it's initial state so that you can reuse it
+ * rather than making new ones.
+ */
+VALUE HttpParser_reset(VALUE self)
+{
+  http_parser *http = NULL;
+  DATA_GET(self, http_parser, http);
+  http_parser_init(http);
+  return Qnil;
+}
+/**
+ * call-seq:
+ *    parser.finish -> true/false
+ *
+ * Finishes a parser early which could put in a "good" or bad state.
+ * You should call reset after finish it or bad things will happen.
+ */
+VALUE HttpParser_finish(VALUE self)
+{
+  http_parser *http = NULL;
+  DATA_GET(self, http_parser, http);
+  http_parser_finish(http);
+  return http_parser_is_finished(http) ? Qtrue : Qfalse;
+}
+/**
+ * call-seq:
+ *    parser.execute(req_hash, data, start) -> Integer
+ *
+ * Takes a Hash and a String of data, parses the String of data filling in the Hash
+ * returning an Integer to indicate how much of the data has been read.  No matter
+ * what the return value, you should call HttpParser#finished? and HttpParser#error?
+ * to figure out if it's done parsing or there was an error.
+ *
+ * This function now throws an exception when there is a parsing error.  This makes
+ * the logic for working with the parser much easier.  You can still test for an
+ * error, but now you need to wrap the parser with an exception handling block.
+ *
+ * The third argument allows for parsing a partial request and then continuing
+ * the parsing from that position.  It needs all of the original data as well
+ * so you have to append to the data buffer as you read.
+ */
+VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
+{
+  http_parser *http = NULL;
+  int from = 0;
+  char *dptr = NULL;
+  long dlen = 0;
+  DATA_GET(self, http_parser, http);
+  from = FIX2INT(start);
+  dptr = RSTRING_PTR(data);
+  dlen = RSTRING_LEN(data);
+  if(from >= dlen) {
+    rb_raise(eHttpParserError, "Requested start is after data buffer end.");
+  } else {
+    http->data = (void *)req_hash;
+    http_parser_execute(http, dptr, dlen, from);
+    VALIDATE_MAX_LENGTH(http_parser_nread(http), HEADER);
+    if(http_parser_has_error(http)) {
+      rb_raise(eHttpParserError, "Invalid HTTP format, parsing fails.");
+    } else {
+      return INT2FIX(http_parser_nread(http));
+    }
+  }
+}
+/**
+ * call-seq:
+ *    parser.error? -> true/false
+ *
+ * Tells you whether the parser is in an error state.
+ */
+VALUE HttpParser_has_error(VALUE self)
+{
+  http_parser *http = NULL;
+  DATA_GET(self, http_parser, http);
+  return http_parser_has_error(http) ? Qtrue : Qfalse;
+}
+/**
+ * call-seq:
+ *    parser.finished? -> true/false
+ *
+ * Tells you whether the parser is finished or not and in a good state.
+ */
+VALUE HttpParser_is_finished(VALUE self)
+{
+  http_parser *http = NULL;
+  DATA_GET(self, http_parser, http);
+  return http_parser_is_finished(http) ? Qtrue : Qfalse;
+}
+/**
+ * call-seq:
+ *    parser.nread -> Integer
+ *
+ * Returns the amount of data processed so far during this processing cycle.  It is
+ * set to 0 on initialize or reset calls and is incremented each time execute is called.
+ */
+VALUE HttpParser_nread(VALUE self)
+{
+  http_parser *http = NULL;
+  DATA_GET(self, http_parser, http);
+  return INT2FIX(http->nread);
+}
+void Init_http11()
+{
+  mMongrel = rb_define_module("Mongrel");
+  DEF_GLOBAL(request_method, "REQUEST_METHOD");
+  DEF_GLOBAL(request_uri, "REQUEST_URI");
+  DEF_GLOBAL(fragment, "FRAGMENT");
+  DEF_GLOBAL(query_string, "QUERY_STRING");
+  DEF_GLOBAL(http_version, "HTTP_VERSION");
+  DEF_GLOBAL(request_path, "REQUEST_PATH");
+  DEF_GLOBAL(content_length, "CONTENT_LENGTH");
+  DEF_GLOBAL(http_content_length, "HTTP_CONTENT_LENGTH");
+  DEF_GLOBAL(content_type, "CONTENT_TYPE");
+  DEF_GLOBAL(http_content_type, "HTTP_CONTENT_TYPE");
+  DEF_GLOBAL(gateway_interface, "GATEWAY_INTERFACE");
+  DEF_GLOBAL(gateway_interface_value, "CGI/1.2");
+  DEF_GLOBAL(server_name, "SERVER_NAME");
+  DEF_GLOBAL(server_port, "SERVER_PORT");
+  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.2.0.pre2"); /* XXX Why is this defined here? */
+  DEF_GLOBAL(server_software, "SERVER_SOFTWARE");
+  DEF_GLOBAL(port_80, "80");
+  eHttpParserError = rb_define_class_under(mMongrel, "HttpParserError", rb_eIOError);
+  cHttpParser = rb_define_class_under(mMongrel, "HttpParser", rb_cObject);
+  rb_define_alloc_func(cHttpParser, HttpParser_alloc);
+  rb_define_method(cHttpParser, "initialize", HttpParser_init,0);
+  rb_define_method(cHttpParser, "reset", HttpParser_reset,0);
+  rb_define_method(cHttpParser, "finish", HttpParser_finish,0);
+  rb_define_method(cHttpParser, "execute", HttpParser_execute,3);
+  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);
+  init_common_fields();
+}