mongrel 0.2.1 → 0.2.2

data/doc/rdoc/classes/Mongrel/URIClassifier.src/{M000016.html → M000020.html}

@@ -16,8 +16,9 @@
  *
  * Registers the SampleHandler (one for all requests) with the "/someuri".
  * When URIClassifier::resolve is called with "/someuri" it'll return
- * SampleHandler immediately.  When "/someuri/pathhere" is called it'll
- * find SomeHandler after a second search, and setup PATH_INFO="/pathhere".
+ * 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.

data/doc/rdoc/classes/Mongrel/URIClassifier.src/{M000018.html → M000022.html}

@@ -32,7 +32,7 @@
  * It also means that it's very efficient to do this only taking as long as the URI has
  * characters.
  *
- * It expects strings.  Don't try other string-line stuff yet.
+ * It expects strings with no embedded '\0' characters.  Don't try other string-line stuff yet.
  */
 VALUE URIClassifier_resolve(VALUE self, VALUE uri)
 {

data/doc/rdoc/created.rid

@@ -1 +1 @@
-Thu Feb 02 01:57:10 EST 2006
+Fri Feb 03 01:14:07 EST 2006

data/doc/rdoc/files/README.html

@@ -56,7 +56,7 @@
     </tr>
     <tr class="top-aligned-row">
       <td><strong>Last Update:</strong></td>
-      <td>Thu Feb 02 01:53:46 EST 2006</td>
+      <td>Fri Feb 03 01:13:51 EST 2006</td>
     </tr>
     </table>
   </div>
@@ -84,7 +84,7 @@ portability issues.
 </p>
 <h2>Status</h2>
 <p>
-The 0.2.1 release of <a href="../classes/Mongrel.html">Mongrel</a> features
+The 0.2.2 release of <a href="../classes/Mongrel.html">Mongrel</a> features
 an HTTP core server that is the fastest possible thing I could get without
 using something other than Ruby. It features a few bug fixes, but mostly
 just a change to the <a
@@ -111,6 +111,12 @@ thanks to Tom Copland. I&#8217;ll be looking to automate management of
 this, but feel free to use rubyforge to post feature requests, bugs, and
 join the mailing list.
 </p>
+<p>
+Finally, it now supports all CGI parameters that don&#8217;t cause a
+performance hit, and it has a <a
+href="../classes/Mongrel/DirHandler.html">Mongrel::DirHandler</a> which can
+serve files out of a directory and do (optional) directory listings.
+</p>
 <h2>Install</h2>
 <p>
 It doesn&#8217;t explicitly require Camping, but if you want to run the
@@ -143,6 +149,7 @@ example:
 
  h = Mongrel::HttpServer.new(&quot;0.0.0.0&quot;, &quot;3000&quot;)
  h.register(&quot;/test&quot;, SimpleHandler.new)
+ h.register(&quot;/files&quot;, DirHandler.new(&quot;.&quot;))
  h.run.join
 </pre>
 <p>
@@ -152,6 +159,11 @@ If you run this and access port 3000 with a browser it will say
 href="../classes/Mongrel/Error404Handler.html">Mongrel::Error404Handler</a>
 for a basic way to give a more complex 404 message.
 </p>
+<p>
+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.*
+</p>
 <h2>Speed</h2>
 <p>
 The 0.2.1 release probably consists of the most effort I&#8217;ve ever put

data/doc/rdoc/files/ext/http11/http11_c.html

@@ -56,7 +56,7 @@
     </tr>
     <tr class="top-aligned-row">
       <td><strong>Last Update:</strong></td>
-      <td>Thu Feb 02 00:12:35 EST 2006</td>
+      <td>Fri Feb 03 00:55:27 EST 2006</td>
     </tr>
     </table>
   </div>

data/doc/rdoc/files/lib/mongrel_rb.html

@@ -56,7 +56,7 @@
     </tr>
     <tr class="top-aligned-row">
       <td><strong>Last Update:</strong></td>
-      <td>Mon Jan 30 23:59:49 EST 2006</td>
+      <td>Fri Feb 03 00:55:27 EST 2006</td>
     </tr>
     </table>
   </div>

data/doc/rdoc/fr_class_index.html

@@ -21,6 +21,8 @@
   <h1 class="section-bar">Classes</h1>
   <div id="index-entries">
     <a href="classes/Mongrel.html">Mongrel</a><br />
+    <a href="classes/Mongrel/Const.html">Mongrel::Const</a><br />
+    <a href="classes/Mongrel/DirHandler.html">Mongrel::DirHandler</a><br />
     <a href="classes/Mongrel/Error404Handler.html">Mongrel::Error404Handler</a><br />
     <a href="classes/Mongrel/HeaderOut.html">Mongrel::HeaderOut</a><br />
     <a href="classes/Mongrel/HttpHandler.html">Mongrel::HttpHandler</a><br />

data/doc/rdoc/fr_method_index.html

@@ -20,31 +20,36 @@
 <div id="index">
   <h1 class="section-bar">Methods</h1>
   <div id="index-entries">
-    <a href="classes/Mongrel/HeaderOut.html#M000014">[]= (Mongrel::HeaderOut)</a><br />
+    <a href="classes/Mongrel/HeaderOut.html#M000018">[]= (Mongrel::HeaderOut)</a><br />
     <a href="classes/Mongrel/HttpParser.html#M000005">error? (Mongrel::HttpParser)</a><br />
     <a href="classes/Mongrel/HttpParser.html#M000004">execute (Mongrel::HttpParser)</a><br />
     <a href="classes/Mongrel/HttpParser.html#M000003">finish (Mongrel::HttpParser)</a><br />
-    <a href="classes/Mongrel/HttpResponse.html#M000022">finished (Mongrel::HttpResponse)</a><br />
+    <a href="classes/Mongrel/HttpResponse.html#M000027">finished (Mongrel::HttpResponse)</a><br />
     <a href="classes/Mongrel/HttpParser.html#M000006">finished? (Mongrel::HttpParser)</a><br />
-    <a href="classes/Mongrel/Error404Handler.html#M000023">new (Mongrel::Error404Handler)</a><br />
-    <a href="classes/Mongrel/HttpServer.html#M000008">new (Mongrel::HttpServer)</a><br />
-    <a href="classes/Mongrel/HttpRequest.html#M000025">new (Mongrel::HttpRequest)</a><br />
-    <a href="classes/Mongrel/HttpResponse.html#M000020">new (Mongrel::HttpResponse)</a><br />
-    <a href="classes/Mongrel/URIClassifier.html#M000015">new (Mongrel::URIClassifier)</a><br />
     <a href="classes/Mongrel/HttpParser.html#M000001">new (Mongrel::HttpParser)</a><br />
-    <a href="classes/Mongrel/HeaderOut.html#M000013">new (Mongrel::HeaderOut)</a><br />
+    <a href="classes/Mongrel/DirHandler.html#M000008">new (Mongrel::DirHandler)</a><br />
+    <a href="classes/Mongrel/HttpResponse.html#M000024">new (Mongrel::HttpResponse)</a><br />
+    <a href="classes/Mongrel/URIClassifier.html#M000019">new (Mongrel::URIClassifier)</a><br />
+    <a href="classes/Mongrel/Error404Handler.html#M000028">new (Mongrel::Error404Handler)</a><br />
+    <a href="classes/Mongrel/HttpServer.html#M000012">new (Mongrel::HttpServer)</a><br />
+    <a href="classes/Mongrel/HeaderOut.html#M000017">new (Mongrel::HeaderOut)</a><br />
+    <a href="classes/Mongrel/HttpRequest.html#M000030">new (Mongrel::HttpRequest)</a><br />
     <a href="classes/Mongrel/HttpParser.html#M000007">nread (Mongrel::HttpParser)</a><br />
-    <a href="classes/Mongrel/Error404Handler.html#M000024">process (Mongrel::Error404Handler)</a><br />
-    <a href="classes/Mongrel/HttpHandler.html#M000019">process (Mongrel::HttpHandler)</a><br />
-    <a href="classes/Mongrel/HttpServer.html#M000009">process_client (Mongrel::HttpServer)</a><br />
-    <a href="classes/Mongrel/HttpServer.html#M000011">register (Mongrel::HttpServer)</a><br />
-    <a href="classes/Mongrel/URIClassifier.html#M000016">register (Mongrel::URIClassifier)</a><br />
+    <a href="classes/Mongrel/Error404Handler.html#M000029">process (Mongrel::Error404Handler)</a><br />
+    <a href="classes/Mongrel/DirHandler.html#M000011">process (Mongrel::DirHandler)</a><br />
+    <a href="classes/Mongrel/HttpHandler.html#M000023">process (Mongrel::HttpHandler)</a><br />
+    <a href="classes/Mongrel/HttpServer.html#M000013">process_client (Mongrel::HttpServer)</a><br />
+    <a href="classes/Mongrel/HttpServer.html#M000015">register (Mongrel::HttpServer)</a><br />
+    <a href="classes/Mongrel/URIClassifier.html#M000020">register (Mongrel::URIClassifier)</a><br />
+    <a href="classes/Mongrel/HttpResponse.html#M000026">reset (Mongrel::HttpResponse)</a><br />
     <a href="classes/Mongrel/HttpParser.html#M000002">reset (Mongrel::HttpParser)</a><br />
-    <a href="classes/Mongrel/URIClassifier.html#M000018">resolve (Mongrel::URIClassifier)</a><br />
-    <a href="classes/Mongrel/HttpServer.html#M000010">run (Mongrel::HttpServer)</a><br />
-    <a href="classes/Mongrel/HttpResponse.html#M000021">start (Mongrel::HttpResponse)</a><br />
-    <a href="classes/Mongrel/URIClassifier.html#M000017">unregister (Mongrel::URIClassifier)</a><br />
-    <a href="classes/Mongrel/HttpServer.html#M000012">unregister (Mongrel::HttpServer)</a><br />
+    <a href="classes/Mongrel/URIClassifier.html#M000022">resolve (Mongrel::URIClassifier)</a><br />
+    <a href="classes/Mongrel/HttpServer.html#M000014">run (Mongrel::HttpServer)</a><br />
+    <a href="classes/Mongrel/DirHandler.html#M000009">send_dir_listing (Mongrel::DirHandler)</a><br />
+    <a href="classes/Mongrel/DirHandler.html#M000010">send_file (Mongrel::DirHandler)</a><br />
+    <a href="classes/Mongrel/HttpResponse.html#M000025">start (Mongrel::HttpResponse)</a><br />
+    <a href="classes/Mongrel/URIClassifier.html#M000021">unregister (Mongrel::URIClassifier)</a><br />
+    <a href="classes/Mongrel/HttpServer.html#M000016">unregister (Mongrel::HttpServer)</a><br />
   </div>
 </div>
 </body>

data/examples/simpletest.rb

@@ -11,6 +11,7 @@ class SimpleHandler < Mongrel::HttpHandler
 end
 
 h = Mongrel::HttpServer.new("0.0.0.0", "3000")
-h.register("/test", SimpleHandler.new)
+h.register("/test;mystuff;thosestuffs", SimpleHandler.new)
+h.register("/files", Mongrel::DirHandler.new("."))
 h.run.join
 

data/ext/http11/http11.c

@@ -13,7 +13,7 @@ static int id_handler_map;
 
 static VALUE global_http_prefix;
 static VALUE global_request_method;
-static VALUE global_path_info;
+static VALUE global_request_uri;
 static VALUE global_query_string;
 static VALUE global_http_version;
 
@@ -45,11 +45,11 @@ void request_method(void *data, const char *at, size_t length)
   rb_hash_aset(req, global_request_method, val);
 }
 
-void path_info(void *data, const char *at, size_t length)
+void request_uri(void *data, const char *at, size_t length)
 {
   VALUE req = (VALUE)data;
   VALUE val = rb_str_new(at, length);
-  rb_hash_aset(req, global_path_info, val);
+  rb_hash_aset(req, global_request_uri, val);
 }
 
 
@@ -87,7 +87,7 @@ VALUE HttpParser_alloc(VALUE klass)
     TRACE();
     hp->http_field = http_field;
     hp->request_method = request_method;
-    hp->path_info = path_info;
+    hp->request_uri = request_uri;
     hp->query_string = query_string;
     hp->http_version = http_version;
     
@@ -279,8 +279,9 @@ VALUE URIClassifier_init(VALUE self)
  *
  * Registers the SampleHandler (one for all requests) with the "/someuri".
  * When URIClassifier::resolve is called with "/someuri" it'll return
- * SampleHandler immediately.  When "/someuri/pathhere" is called it'll
- * find SomeHandler after a second search, and setup PATH_INFO="/pathhere".
+ * 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.
@@ -357,7 +358,7 @@ VALUE URIClassifier_unregister(VALUE self, VALUE uri)
  * It also means that it's very efficient to do this only taking as long as the URI has
  * characters.
  *
- * It expects strings.  Don't try other string-line stuff yet.
+ * It expects strings with no embedded '\0' characters.  Don't try other string-line stuff yet.
  */
 VALUE URIClassifier_resolve(VALUE self, VALUE uri)
 {
@@ -401,8 +402,8 @@ void Init_http11()
   rb_global_variable(&global_http_prefix);
   global_request_method = rb_str_new2("REQUEST_METHOD");
   rb_global_variable(&global_request_method);
-  global_path_info = rb_str_new2("PATH_INFO");
-  rb_global_variable(&global_path_info);
+  global_request_uri = rb_str_new2("REQUEST_URI");
+  rb_global_variable(&global_request_uri);
   global_query_string = rb_str_new2("QUERY_STRING");
   rb_global_variable(&global_query_string);
   global_http_version = rb_str_new2("HTTP_VERSION");

data/ext/http11/http11_parser.c

@@ -9,7 +9,7 @@
 #define MARK(S,F) assert((F) - (S)->mark >= 0); (S)->mark = (F);
 
 /** machine **/
-#line 100 "ext/http11/http11_parser.rl"
+#line 98 "ext/http11/http11_parser.rl"
 
 
 /** Data **/
@@ -21,7 +21,7 @@ static int http_parser_first_final = 56;
 
 static int http_parser_error = 1;
 
-#line 104 "ext/http11/http11_parser.rl"
+#line 102 "ext/http11/http11_parser.rl"
 
 int http_parser_init(http_parser *parser)  {
     int cs = 0;
@@ -30,7 +30,7 @@ int http_parser_init(http_parser *parser)  {
 	{
 	cs = http_parser_start;
 	}
-#line 108 "ext/http11/http11_parser.rl"
+#line 106 "ext/http11/http11_parser.rl"
     parser->cs = cs;
     parser->body_start = NULL;
     parser->content_len = 0;
@@ -158,8 +158,8 @@ case 9:
 tr34:
 #line 33 "ext/http11/http11_parser.rl"
 	{ 
-	       if(parser->path_info != NULL)
-	       	       parser->path_info(parser->data, parser->mark, p - parser->mark);
+	       if(parser->request_uri != NULL)
+	       	       parser->request_uri(parser->data, parser->mark, p - parser->mark);
 	}
 	goto st10;
 tr48:
@@ -601,8 +601,8 @@ case 35:
 tr46:
 #line 33 "ext/http11/http11_parser.rl"
 	{ 
-	       if(parser->path_info != NULL)
-	       	       parser->path_info(parser->data, parser->mark, p - parser->mark);
+	       if(parser->request_uri != NULL)
+	       	       parser->request_uri(parser->data, parser->mark, p - parser->mark);
 	}
 	goto st36;
 st36:
@@ -875,7 +875,7 @@ case 55:
 
 	_out: {}
 	}
-#line 127 "ext/http11/http11_parser.rl"
+#line 125 "ext/http11/http11_parser.rl"
 
     parser->cs = cs;
     parser->nread = p - buffer;
@@ -883,7 +883,7 @@ case 55:
         /* final \r\n combo encountered so stop right here */
 	
 #line 886 "ext/http11/http11_parser.c"
-#line 133 "ext/http11/http11_parser.rl"
+#line 131 "ext/http11/http11_parser.rl"
 	parser->nread++;
     }
 
@@ -896,7 +896,7 @@ int http_parser_finish(http_parser *parser)
 
 	
 #line 899 "ext/http11/http11_parser.c"
-#line 144 "ext/http11/http11_parser.rl"
+#line 142 "ext/http11/http11_parser.rl"
 
 	parser->cs = cs;
 

data/ext/http11/http11_parser.h

@@ -3,6 +3,10 @@
 
 #include <sys/types.h>
 
+#if defined(_WIN32)
+#include <stddef.h>
+#endif
+
 typedef void (*element_cb)(void *data, const char *at, size_t length);
 typedef void (*field_cb)(void *data, const char *field, size_t flen, const char *value, size_t vlen);
 
@@ -19,7 +23,7 @@ typedef struct http_parser {
 
   field_cb http_field;
   element_cb request_method;
-  element_cb path_info;
+  element_cb request_uri;
   element_cb query_string;
   element_cb http_version;
 

data/lib/#mongrel.rb#

@@ -0,0 +1,493 @@
+require 'socket'
+require 'http11'
+require 'thread'
+require 'stringio'
+
+# Mongrel module containing all of the classes (include C extensions) for running
+# a Mongrel web server.  It contains a minimalist HTTP server with just enough
+# functionality to service web application requests fast as possible.
+module Mongrel
+
+  # Every standard HTTP code mapped to the appropriate message.  These are
+  # used so frequently that they are placed directly in Mongrel for easy
+  # access rather than Mongrel::Const.
+  HTTP_STATUS_CODES = {  
+    100  => 'Continue', 
+    101  => 'Switching Protocols', 
+    200  => 'OK', 
+    201  => 'Created', 
+    202  => 'Accepted', 
+    203  => 'Non-Authoritative Information', 
+    204  => 'No Content', 
+    205  => 'Reset Content', 
+    206  => 'Partial Content', 
+    300  => 'Multiple Choices', 
+    301  => 'Moved Permanently', 
+    302  => 'Moved Temporarily', 
+    303  => 'See Other', 
+    304  => 'Not Modified', 
+    305  => 'Use Proxy', 
+    400  => 'Bad Request', 
+    401  => 'Unauthorized', 
+    402  => 'Payment Required', 
+    403  => 'Forbidden', 
+    404  => 'Not Found', 
+    405  => 'Method Not Allowed', 
+    406  => 'Not Acceptable', 
+    407  => 'Proxy Authentication Required', 
+    408  => 'Request Time-out', 
+    409  => 'Conflict', 
+    410  => 'Gone', 
+    411  => 'Length Required', 
+    412  => 'Precondition Failed', 
+    413  => 'Request Entity Too Large', 
+    414  => 'Request-URI Too Large', 
+    415  => 'Unsupported Media Type', 
+    500  => 'Internal Server Error', 
+    501  => 'Not Implemented', 
+    502  => 'Bad Gateway', 
+    503  => 'Service Unavailable', 
+    504  => 'Gateway Time-out', 
+    505  => 'HTTP Version not supported'
+  }
+
+  # Frequently used constants when constructing requests or responses.  Many times
+  # the constant just refers to a string with the same contents.  Using these constants
+  # gave about a 3% to 10% performance improvement over using the strings directly.
+  # Symbols did not really improve things much compared to constants.
+  #
+  # While Mongrel does try to emulate the CGI/1.2 protocol, it does not use the REMOTE_IDENT,
+  # REMOTE_USER, or REMOTE_HOST parameters since those are either a security problem or 
+  # too taxing on performance.
+  module Const
+    # This is the part of the path after the SCRIPT_NAME.  URIClassifier will determine this.
+    PATH_INFO="PATH_INFO"
+    # This is the intial part that your handler is identified as by URIClassifier.
+    SCRIPT_NAME="SCRIPT_NAME"
+    # The original URI requested by the client.  Passed to URIClassifier to build PATH_INFO and SCRIPT_NAME.
+    REQUEST_URI='REQUEST_URI'
+
+    # Content length (also available as HTTP_CONTENT_LENGTH).
+    CONTENT_LENGTH='CONTENT_LENGTH'
+
+    # Content length (also available as CONTENT_LENGTH).
+    HTTP_CONTENT_LENGTH='HTTP_CONTENT_LENGTH'
+
+    # Content type (also available as HTTP_CONTENT_TYPE).
+    CONTENT_TYPE='CONTENT_TYPE'
+
+    # Content type (also available as CONTENT_TYPE).
+    HTTP_CONTENT_TYPE='HTTP_CONTENT_TYPE'
+
+    # Gateway interface key in the HttpRequest parameters.
+    GATEWAY_INTERFACE='GATEWAY_INTERFACE'
+    # We claim to support CGI/1.2.
+    GATEWAY_INTERFACE_VALUE='CGI/1.2'
+
+    # Hosts remote IP address.  Mongrel does not do DNS resolves since that slows 
+    # processing down considerably.
+    REMOTE_ADDR='REMOTE_ADDR'
+
+    # This is not given since Mongrel does not do DNS resolves.  It is only here for
+    # completeness for the CGI standard.
+    REMOTE_HOST='REMOTE_HOST'
+
+    # The name/host of our server as given by the HttpServer.new(host,port) call.
+    SERVER_NAME='SERVER_NAME'
+
+    # The port of our server as given by the HttpServer.new(host,port) call.
+    SERVER_PORT='SERVER_PORT'
+
+    # Official server protocol key in the HttpRequest parameters.
+    SERVER_PROTOCOL='SERVER_PROTOCOL'
+    # Mongrel claims to support HTTP/1.1.
+    SERVER_PROTOCOL_VALUE='HTTP/1.1'
+
+    # The actual server software being used (it's Mongrel man).
+    SERVER_SOFTWARE='SERVER_SOFTWARE'
+    
+    # Current Mongrel version (used for SERVER_SOFTWARE and other response headers).
+    MONGREL_VERSION='Mongrel 0.2.2'
+
+    # The standard empty 404 response for bad requests.  Use Error4040Handler for custom stuff.
+    ERROR_404_RESPONSE="HTTP/1.1 404 Not Found\r\nConnection: close\r\nServer: #{MONGREL_VERSION}\r\n\r\nNOT FOUND"
+
+    # A common header for indicating the server is too busy.  Not used yet.
+    ERROR_503_RESPONSE="HTTP/1.1 503 Service Unavailable\r\n\r\nBUSY"
+
+    # The basic max request size we'll try to read.
+    CHUNK_SIZE=(16 * 1024)
+
+  end
+
+
+  # When a handler is found for a registered URI then this class is constructed
+  # and passed to your HttpHandler::process method.  You should assume that 
+  # *one* handler processes all requests.  Included in the HttpReqeust is a
+  # HttpRequest.params Hash that matches common CGI params, and a HttpRequest.body
+  # which is a string containing the request body (raw for now).
+  #
+  # Mongrel really only supports small-ish request bodies right now since really
+  # huge ones have to be completely read off the wire and put into a string.
+  # Later there will be several options for efficiently handling large file
+  # uploads.
+  class HttpRequest
+    attr_reader :body, :params
+
+    # You don't really call this.  It's made for you.
+    # Main thing it does is hook up the params, and store any remaining
+    # body data into the HttpRequest.body attribute.
+    def initialize(params, initial_body, socket)
+      @body = initial_body || ""
+      @params = params
+      @socket = socket
+      
+      # fix up the CGI requirements
+      params[Const::CONTENT_LENGTH] = params[Const::HTTP_CONTENT_LENGTH] || 0
+      params[Const::CONTENT_TYPE] ||= params[Const::HTTP_CONTENT_TYPE]
+
+      # now, if the initial_body isn't long enough for the content length we have to fill it
+      # TODO: adapt for big ass stuff by writing to a temp file
+      clen = params[Const::HTTP_CONTENT_LENGTH].to_i
+      if @body.length < clen
+        @body << @socket.read(clen - @body.length)
+      end
+    end
+  end
+
+
+  # This class implements a simple way of constructing the HTTP headers dynamically
+  # via a Hash syntax.  Think of it as a write-only Hash.  Refer to HttpResponse for
+  # information on how this is used.
+  #
+  # One consequence of this write-only nature is that you can write multiple headers
+  # by just doing them twice (which is sometimes needed in HTTP), but that the normal
+  # semantics for Hash (where doing an insert replaces) is not there.
+  class HeaderOut
+    attr_reader :out
+
+    def initialize(out)
+      @out = out
+    end
+
+    # Simply writes "#{key}: #{value}" to an output buffer.
+    def[]=(key,value)
+      @out.write(key)
+      @out.write(": ")
+      @out.write(value)
+      @out.write("\r\n")
+    end
+  end
+
+  # Writes and controls your response to the client using the HTTP/1.1 specification.
+  # You use it by simply doing:
+  #
+  #  response.start(200) do |head,out|
+  #    head['Content-Type'] = 'text/plain'
+  #    out.write("hello\n")
+  #  end
+  #
+  # The parameter to start is the response code--which Mongrel will translate for you
+  # based on HTTP_STATUS_CODES.  The head parameter is how you write custom headers.
+  # The out parameter is where you write your body.  The default status code for 
+  # HttpResponse.start is 200 so the above example is redundant.
+  # 
+  # As you can see, it's just like using a Hash and as you do this it writes the proper
+  # header to the output on the fly.  You can even intermix specifying headers and 
+  # writing content.  The HttpResponse class with write the things in the proper order
+  # once the HttpResponse.block is ended.
+  #
+  # You may also work the HttpResponse object directly using the various attributes available
+  # for the raw socket, body, header, and status codes.  If you do this you're on your own.
+  # A design decision was made to force the client to not pipeline requests.  HTTP/1.1 
+  # pipelining really kills the performance due to how it has to be handled and how 
+  # unclear the standard is.  To fix this the HttpResponse gives a "Connection: close"
+  # header which forces the client to close right away.  The bonus for this is that it
+  # gives a pretty nice speed boost to most clients since they can close their connection
+  # immediately.
+  #
+  # One additional caveat is that you don't have to specify the Content-length header
+  # as the HttpResponse will write this for you based on the out length.
+  class HttpResponse
+    attr_reader :socket
+    attr_reader :body
+    attr_reader :header
+    attr_reader :status
+    attr_writer :status
+    
+    def initialize(socket)
+      @socket = socket
+      @body = StringIO.new
+      @status = 404
+      @header = HeaderOut.new(StringIO.new)
+    end
+
+    # Receives a block passing it the header and body for you to work with.
+    # When the block is finished it writes everything you've done to 
+    # the socket in the proper order.  This lets you intermix header and
+    # body content as needed.
+    def start(status=200)
+      @status = status
+      yield @header, @body
+      finished
+    end
+
+    # Primarily used in exception handling to reset the response output in order to write
+    # an alternative response.
+    def reset
+      @header.out.rewind
+      @body.rewind
+    end
+
+    # This takes whatever has been done to header and body and then writes it in the
+    # proper format to make an HTTP/1.1 response.
+    def finished
+      @header.out.rewind
+      @body.rewind
+      
+      # connection: close is also added to ensure that the client does not pipeline.
+      @socket.write("HTTP/1.1 #{@status} #{HTTP_STATUS_CODES[@status]}\r\nContent-Length: #{@body.length}\r\nConnection: close\r\n")
+      @socket.write(@header.out.read)
+      @socket.write("\r\n")
+      @socket.write(@body.read)
+    end
+  end
+  
+
+  # You implement your application handler with this.  It's very light giving
+  # just the minimum necessary for you to handle a request and shoot back 
+  # a response.  Look at the HttpRequest and HttpResponse objects for how
+  # to use them.
+  class HttpHandler
+    def process(request, response)
+    end
+  end
+
+
+  # This is the main driver of Mongrel, while the Mognrel::HttpParser and Mongrel::URIClassifier
+  # make up the majority of how the server functions.  It's a very simple class that just
+  # has a thread accepting connections and a simple HttpServer.process_client function
+  # to do the heavy lifting with the IO and Ruby.  
+  #
+  # You use it by doing the following:
+  #
+  #   server = HttpServer.new("0.0.0.0", 3000)
+  #   server.register("/stuff", MyNifterHandler.new)
+  #   server.run.join
+  #
+  # The last line can be just server.run if you don't want to join the thread used.
+  # If you don't though Ruby will mysteriously just exit on you.
+  #
+  # Ruby's thread implementation is "interesting" to say the least.  Experiments with
+  # *many* different types of IO processing simply cannot make a dent in it.  Future
+  # releases of Mongrel will find other creative ways to make threads faster, but don't
+  # hold your breath until Ruby 1.9 is actually finally useful.
+  class HttpServer
+    attr_reader :acceptor
+
+    # Creates a working server on host:port (strange things happen if port isn't a Number).
+    # Use HttpServer::run to start the server.
+    #
+    # The num_processors variable has varying affects on how requests are processed.  You'd
+    # think adding more processing threads (processors) would make the server faster, but
+    # that's just not true.  There's actually an effect of how Ruby does threads such that
+    # the more processors waiting on the request queue, the slower the system is to handle
+    # each request.  But, the lower the number of processors the fewer concurrent responses
+    # the server can make.
+    #
+    # 20 is the default number of processors and is based on experimentation on a few
+    # systems.  If you find that you overload Mongrel too much
+    # try changing it higher.  If you find that responses are way too slow
+    # try lowering it (after you've tuned your stuff of course).
+    # Future versions of Mongrel will make this more dynamic (hopefully).
+    def initialize(host, port, num_processors=20)
+      @socket = TCPServer.new(host, port)
+
+      @classifier = URIClassifier.new
+      @req_queue = Queue.new
+      @host = host
+      @port = port
+      @num_procesors = num_processors
+
+      num_processors.times {|i| Thread.new do
+          while client = @req_queue.deq
+            process_client(client)
+          end
+        end
+      }
+    end
+    
+
+    # Does the majority of the IO processing.  It has been written in Ruby using
+    # about 7 different IO processing strategies and no matter how it's done 
+    # the performance just does not improve.  It is currently carefully constructed
+    # to make sure that it gets the best possible performance, but anyone who
+    # thinks they can make it faster is more than welcome to take a crack at it.
+    def process_client(client)
+      begin
+        parser = HttpParser.new
+        params = {}
+        data = client.readpartial(Const::CHUNK_SIZE)
+
+        while true
+          nread = parser.execute(params, data)
+          if parser.finished?
+            script_name, path_info, handler = @classifier.resolve(params[Const::REQUEST_URI])
+
+            if handler
+              params[Const::PATH_INFO] = path_info
+              params[Const::SCRIPT_NAME] = script_name
+              params[Const::GATEWAY_INTERFACE]=Const::GATEWAY_INTERFACE_VALUE
+              params[Const::REMOTE_ADDR]=client.peeraddr
+              params[Const::SERVER_NAME]=@host
+              params[Const::SERVER_PORT]=@port
+              params[Const::SERVER_PROTOCOL]=Const::SERVER_PROTOCOL_VALUE
+              params[Const::SERVER_SOFTWARE]=Const::MONGREL_VERSION
+
+              request = HttpRequest.new(params, data[nread ... data.length], client)
+              response = HttpResponse.new(client)
+              handler.process(request, response)
+            else
+              client.write(Const::ERROR_404_RESPONSE)
+            end
+
+            break
+          else
+            # gotta stream and read again until we can get the parser to be character safe
+            # TODO: make this more efficient since this means we're parsing a lot repeatedly
+            parser.reset
+            data << client.readpartial(Const::CHUNK_SIZE)
+          end
+        end
+      rescue EOFError
+        # ignored
+      rescue Errno::ECONNRESET
+        # ignored
+      rescue Errno::EPIPE
+        # ignored
+      rescue => details
+        STDERR.puts "ERROR(#{details.class}): #{details}"
+        STDERR.puts details.backtrace.join("\n")
+      ensure
+        client.close
+      end
+    end
+
+    # Runs the thing.  It returns the thread used so you can "join" it.  You can also
+    # access the HttpServer::acceptor attribute to get the thread later.
+    def run
+      BasicSocket.do_not_reverse_lookup=true
+      @acceptor = Thread.new do
+        while true
+          @req_queue << @socket.accept
+        end
+      end
+    end
+
+    
+    # Simply registers a handler with the internal URIClassifier.  When the URI is
+    # found in the prefix of a request then your handler's HttpHandler::process method
+    # is called.  See Mongrel::URIClassifier#register for more information.
+    def register(uri, handler)
+      @classifier.register(uri, handler)
+    end
+
+    # Removes any handler registered at the given URI.  See Mongrel::URIClassifier#unregister
+    # for more information.
+    def unregister(uri)
+      @classifier.unregister(uri)
+    end
+  end
+
+
+  # The server normally returns a 404 response if a URI is requested, but it
+  # also returns a lame empty message.  This lets you do a 404 response
+  # with a custom message for special URIs.
+  class Error404Handler < HttpHandler
+
+    # Sets the message to return.  This is constructed once for the handler
+    # so it's pretty efficient.
+    def initialize(msg)
+      @response = HttpServer::ERROR_404_RESPONSE + msg
+    end
+    
+    # Just kicks back the standard 404 response with your special message.
+    def process(request, response)
+      response.socket.write(@response)
+    end
+
+  end
+
+
+  # Serves the contents of a directory.  You give it the path to the root
+  # where the files are located, and it tries to find the files based on 
+  # the PATH_INFO inside the directory.  If the requested path is a
+  # directory then it returns a simple directory listing.
+  #
+  # It does a simple protection against going outside it's root path by
+  # converting all paths to an absolute expanded path, and then making sure
+  # that the final expanded path includes the root path.  If it doesn't
+  # than it simply gives a 404.
+  class DirHandler < HttpHandler
+
+    # You give it the path to the directory root and an (optional) 
+    def initialize(path, listing_allowed=true)
+      @path = File.expand_path(path)
+      @listing_allowed=listing_allowed
+      puts "DIR: #@path"
+    end
+
+    def send_dir_listing(base, dir, response)
+      if @listing_allowed
+        response.start(200) do |head,out|
+          head['Content-Type'] = "text/html"
+          out << "<html><head><title>Directory Listing</title></head><body>"
+          Dir.entries(dir).each do |child|
+            out << "<a href=\"#{base}/#{child}\">#{child}</a><br/>"
+          end
+          out << "</body></html>"
+        end
+      else
+        response.start(403) do |head,out|
+          out.write("Directory listings not allowed")
+        end
+      end
+    end
+
+
+    def send_file(req, response)
+      response.start(200) do |head,out|
+        open(req, "r") do |f|
+          out.write(f.read)
+        end
+      end
+    end
+
+
+    def process(request, response)
+      req = File.expand_path("." + request.params['PATH_INFO'], @path)
+      puts "FIND: #{req}"
+      if req.index(@path) != 0 or !File.exist? req
+        # not found, return a 404
+        response.start(404) do |head,out|
+          out << "File not found"
+        end
+      else
+        begin
+          if File.directory? req
+            send_dir_listing(request.params["REQUEST_URI"],req, response)
+          else
+            send_file(req, response)
+          end
+        rescue => details
+          response.reset
+          response.start(403) do |head,out|
+            out << "Error accessing file"
+          end
+          STDERR.puts "ERROR: #{details}"
+        end
+      end
+    end
+  end
+
+end